优化支持自定义logger

导出RankData.RefreshTimestamp

README.md

@@ -1,5 +1,5 @@
 origin 游戏服务器引擎简介
--------------------------
+=========================
 
 origin 是一个由 Go 语言（golang）编写的分布式开源游戏服务器引擎。origin适用于各类游戏服务器的开发，包括 H5（HTML5）游戏服务器。
 
@@ -17,12 +17,8 @@ Hello world!
 下面我们来一步步的建立origin服务器,先下载[origin引擎](https://github.com/duanhf2012/origin "origin引擎"),或者使用如下命令：
 
 ```go
-go get -v -u  github.com/duanhf2012/origin/v2
+go get -v -u  github.com/duanhf2012/origin
 ```
-建议使用origin v2版本（import引用中都加入v2）
-
-
-
 [README.md](README.md)
 于是下载到GOPATH环境目录中,在src中加入main.go,内容如下：
 
@@ -30,7 +26,7 @@ go get -v -u  github.com/duanhf2012/origin/v2
 package main
 
 import (
-	"github.com/duanhf2012/origin/v2/node"
+	"github.com/duanhf2012/origin/node"
 )
 
 func main() {
@@ -57,140 +53,29 @@ origin引擎三大对象关系
 
 origin集群核心配置文件在config的cluster目录下，如github.com/duanhf2012/originserver的config/cluster目录下有cluster.json与service.json配置：
 
-## origin配置说明
-
-origin的配置文件以json格式，主要包含Discovery、RpcMode、NodeList、Service部分，具体格式如下：
-
-```json
-{
-    "Discovery":{},
-    "RpcMode":{},
-    "NodeList":[],
-	"Service":{},
-    "Global": {}
-}
-```
-
-
-
-
-
-### Discovery部分
-
-origin目前支持etcd与origin自带的服务发现类型。
-
-
-
-Etcd方式示例：
-
-```json
-  "Discovery": {
-    "Etcd": {
-      "TTLSecond": 10,
-      "DialTimeoutMillisecond": 3000,
-      "EtcdList": [
-        {
-          "NetworkName": ["network1"],
-          "Endpoints": ["http://192.168.13.24:12379"]
-        }
-      ]
-    }
-  }
-```
-
-TTLSecond：表示健康检查TTL失效时间10秒
-
-DialTimeoutMillisecond: 与etcd连接超时时间
-
-EtcdList：Etcd列表，可以多个Etcd服务器连接
-
-NetworkName：所在的网络名称，可以配置多个。node会往对应的网络名称中注册、监听发现Service。NetworkName也起到发现隔离的作用。
-
-Endpoints：Etcd服务器地址
-
-
-
-Origin方式示例：
-
-```json
-{
-  "Discovery": {
-    "Origin":{
-      "TTLSecond": 10,
-      "MasterNodeList": [
-        {
-          "NodeId": "test_1",
-          "ListenAddr": "127.0.0.1:8801"
-        }
-      ]
-    }
-  }
-}
-```
-
-TTLSecond：表示健康检查TTL失效时间10秒
-
-MasterNodeList：指定哪些Node为服务发现Master结点，需要配置NodeId与ListenAddr，注意它们要与实际的Node配置一致。
-
-
-
-### RpcMode部分
-
-默认模式
-
-```json
-{
-	"RpcMode":{
-		"Type": "Default"
-	}
-}
-```
-
-默认模式下，origin的node之前通过tcp连接组网。
-
-
-
-Nats模式
-
-```json
-{
-	"RpcMode":{
-		"Type": "Nats",
-		"remark": "support Default or Nats",
-		"Nats": {
-			"NatsUrl":"127.0.0.1:4222",
-			"NoRandomize": true
-		}
-	}
-}
-```
-
-NatsUrl：Nats连接url串
-
-NoRandomize:在多连接集群模式下，连接nats节点是否顺序策略。false表示随机连接，true表示顺序连接。
-
-
-
-### NodeList部分
+cluster.json如下：
+------------------
 
 ```
 {
     "NodeList":[
         {
-          "NodeId": "node_1",
+          "NodeId": 1,
           "Private": false,
           "ListenAddr":"127.0.0.1:8001",
           "MaxRpcParamLen": 409600,
           "CompressBytesLen": 20480,
+          "NodeName": "Node_Test1",
           "remark":"//以_打头的，表示只在本机进程，不对整个子网公开",
           "ServiceList": ["TestService1","TestService2","TestServiceCall","GateService","_TcpService","HttpService","WSService"]
         },
         {
-          "NodeId": "node_2",
+          "NodeId": 2,
           "Private": false,
           "ListenAddr":"127.0.0.1:8002",
           "MaxRpcParamLen": 409600,
           "CompressBytesLen": 20480,
+          "NodeName": "Node_Test1",
           "remark":"//以_打头的，表示只在本机进程，不对整个子网公开",
           "ServiceList": ["TestService1","TestService2","TestServiceCall","GateService","TcpService","HttpService","WSService"]
         }
@@ -201,27 +86,27 @@ NoRandomize:在多连接集群模式下，连接nats节点是否顺序策略。f
 
 以上配置了两个结点服务器程序:
 
-* NodeId: 表示origin程序的结点Id标识，同一个服务发现网络中不允许重复。
+* NodeId: 表示origin程序的结点Id标识，不允许重复。
 * Private: 是否私有结点，如果为true，表示其他结点不会发现它，但可以自我运行。
 * ListenAddr:Rpc通信服务的监听地址
 * MaxRpcParamLen:Rpc参数数据包最大长度，该参数可以缺省，默认一次Rpc调用支持最大4294967295byte长度数据。
 * CompressBytesLen:Rpc网络数据压缩，当数据>=20480byte时将被压缩。该参数可以缺省或者填0时不进行压缩。
+* NodeName:结点名称
 * remark:备注，可选项
 * ServiceList:该Node拥有的服务列表，注意：origin按配置的顺序进行安装初始化。但停止服务的顺序是相反。
 
 ---
 
-在启动程序命令originserver -start nodeid="node_1"中nodeid就是根据该配置装载服务。
+在启动程序命令originserver -start nodeid=1中nodeid就是根据该配置装载服务。
 更多参数使用，请使用originserver -help查看。
-
-
-
-### Service 部分
-
 service.json如下：
+------------------
 
 ```
 {
+"Global": {
+		"AreaId": 1
+	},
   "Service":{
 	  "HttpService":{
 		"ListenAddr":"0.0.0.0:9402",
@@ -321,32 +206,6 @@ service.json如下：
 * PendingWriteNum：发送网络队列最大数量
 * MaxMsgLen:包最大长度
 
-
-
-### Global部分
-
-```json
-{
-"Global": {
-		"AreaId": 1
-	}
-}
-```
-
-这部分，在所有的服务中都可以类似以下代码获取：
-
-```go
-globalCfg := cluster.GetCluster().GetGlobalCfg()
-mapGlobal, ok := globalCfg.(map[string]interface{})
-if ok == false {
-	return fmt.Errorf("Canot find Global from config.")
-}
-
-areaId, ok := mapGlobal["AreaId"]
-```
-
-
-
 ---
 
 第一章：origin基础:
@@ -360,8 +219,8 @@ simple_service/TestService1.go如下：
 package simple_service
 
 import (
-	"github.com/duanhf2012/origin/v2/node"
-	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/node"
+	"github.com/duanhf2012/origin/service"
 )
 
 //模块加载时自动安装TestService1服务
@@ -371,6 +230,7 @@ func init(){
 
 //新建自定义服务TestService1
 type TestService1 struct {
+
 	//所有的自定义服务必需加入service.Service基服务
 	//那么该自定义服务将有各种功能特性
 	//例如: Rpc,事件驱动,定时器等
@@ -389,8 +249,8 @@ simple_service/TestService2.go如下：
 
 ```
 import (
-	"github.com/duanhf2012/origin/v2/node"
-	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/node"
+	"github.com/duanhf2012/origin/service"
 )
 
 func init(){
@@ -414,7 +274,7 @@ func (slf *TestService2) OnInit() error {
 package main
 
 import (
-	"github.com/duanhf2012/origin/v2/node"
+	"github.com/duanhf2012/origin/node"
 	//导入simple_service模块
 	_"orginserver/simple_service"
 )
@@ -431,9 +291,10 @@ func main(){
 {
     "NodeList":[
         {
-          "NodeId": "nodeid_1",
+          "NodeId": 1,
           "Private": false,
           "ListenAddr":"127.0.0.1:8001",
+          "NodeName": "Node_Test1",
 		  "remark":"//以_打头的，表示只在本机进程，不对整个子网开发",
           "ServiceList": ["TestService1","TestService2"]
         }
@@ -444,7 +305,7 @@ func main(){
 编译后运行结果如下：
 
 ```
-#originserver -start nodeid="nodeid_1"
+#originserver -start nodeid=1
 TestService1 OnInit.
 TestService2 OnInit.
 ```
@@ -592,8 +453,8 @@ package simple_module
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/node"
-	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/node"
+	"github.com/duanhf2012/origin/service"
 )
 
 func init(){
@@ -672,9 +533,9 @@ Module1 Release.
 package simple_event
 
 import (
-	"github.com/duanhf2012/origin/v2/event"
-	"github.com/duanhf2012/origin/v2/node"
-	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/event"
+	"github.com/duanhf2012/origin/node"
+	"github.com/duanhf2012/origin/service"
 	"time"
 )
 
@@ -717,9 +578,9 @@ package simple_event
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/event"
-	"github.com/duanhf2012/origin/v2/node"
-	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/event"
+	"github.com/duanhf2012/origin/node"
+	"github.com/duanhf2012/origin/service"
 )
 
 func init(){
@@ -788,8 +649,8 @@ simple_rpc/TestService6.go文件如下：
 package simple_rpc
 
 import (
-	"github.com/duanhf2012/origin/v2/node"
-	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/node"
+	"github.com/duanhf2012/origin/service"
 )
 
 func init(){
@@ -824,8 +685,8 @@ package simple_rpc
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/node"
-	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/node"
+	"github.com/duanhf2012/origin/service"
 	"time"
 )
 
@@ -859,7 +720,7 @@ func (slf *TestService7) CallTest(){
 	}
 	
 	
-	//自定义超时,默认rpc超时时间为15s,以下设置1秒钟超过
+	//自定义超时,默认rpc超时时间为15s
 	err = slf.CallWithTimeout(time.Second*1, "TestService6.RPC_Sum", &input, &output)
 	if err != nil {
 		fmt.Printf("Call error :%+v\n", err)
@@ -987,35 +848,45 @@ func (slf *TestService13) testAsyncDo() {
 ```
 
 
-第七章：服务发现
+第七章：配置服务发现
 --------------------
 
-origin引擎默认使用读取所有结点配置的进行确认结点有哪些Service。引擎也支持动态服务发现的方式，支持etcd与origin类型，具体请参照【配置说明】部分，Node结点可以配置只发现某些服务，如下示例：
+origin引擎默认使用读取所有结点配置的进行确认结点有哪些Service。引擎也支持动态服务发现的方式，使用了内置的DiscoveryMaster服务用于中心Service，DiscoveryClient用于向DiscoveryMaster获取整个origin网络中所有的结点以及服务信息。具体实现细节请查看这两部分的服务实现。具体使用方式，在以下cluster配置中加入以下内容：
 
 ```
 {
+	"MasterDiscoveryNode": [{
+		"NodeId": 2,
+		"ListenAddr": "127.0.0.1:10001",
+		"MaxRpcParamLen": 409600
+	},
+	{
+		"NodeId": 1,
+		"ListenAddr": "127.0.0.1:8801",
+		"MaxRpcParamLen": 409600
+	}],
+
+
 	"NodeList": [{
-		"NodeId": "nodeid_test",
+		"NodeId": 1,
 		"ListenAddr": "127.0.0.1:8801",
 		"MaxRpcParamLen": 409600,
+		"NodeName": "Node_Test1",
 		"Private": false,
 		"remark": "//以_打头的，表示只在本机进程，不对整个子网开发",
 		"ServiceList": ["_TestService1", "TestService9", "TestService10"],
-	    "DiscoveryService": [
+	    "MasterDiscoveryService": [
 		    {
-                "MasterNodeId": "nodeid_1",
-                "NetworkName":"networkname1"
+                "MasterNodeId": 2,
                 "DiscoveryService": ["TestService8"]
             }
 	    ]
 	}]
 }
 ```
-DiscoveryService：在当前nodeid为nodeid_test的结点中，只发现 MasterNodeId为nodeid_1或NetworkName为networkname1网络中的TestService8服务。
-
-**注意**：MasterNodeId与NetworkName只配置一个，分别在模式为origin或者etcd服务发现类型时。
-
+MasterDiscoveryNode: 配置了结点Id为1的服务发现Master，他的监听地址ListenAddr为127.0.0.1:8801，结点为2的也是一个服务发现Master。NodeId为1的结点会从结点为1和2的网络中发现服务。
 
+MasterDiscoveryService: 表示将筛选origin网络中MasterNodeId为2中的TestService8服务，注意如果MasterDiscoveryService不配置，则筛选功能不生效。MasterNodeId也可以填为0，表示NodeId为1的结点，在所有网络中只发现TestService8的服务。
 
 第八章：HttpService使用
 -----------------------
@@ -1029,9 +900,9 @@ package simple_http
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/node"
-	"github.com/duanhf2012/origin/v2/service"
-	"github.com/duanhf2012/origin/v2/sysservice"
+	"github.com/duanhf2012/origin/node"
+	"github.com/duanhf2012/origin/service"
+	"github.com/duanhf2012/origin/sysservice"
 	"net/http"
 )
 
@@ -1108,10 +979,10 @@ package simple_tcp
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/network/processor"
-	"github.com/duanhf2012/origin/v2/node"
-	"github.com/duanhf2012/origin/v2/service"
-	"github.com/duanhf2012/origin/v2/sysservice"
+	"github.com/duanhf2012/origin/network/processor"
+	"github.com/duanhf2012/origin/node"
+	"github.com/duanhf2012/origin/service"
+	"github.com/duanhf2012/origin/sysservice"
 	"github.com/golang/protobuf/proto"
 	"orginserver/simple_tcp/msgpb"
 )
@@ -1148,16 +1019,16 @@ func (slf *TestTcpService) OnInit() error {
 }
 
 
-func (slf *TestTcpService) OnConnected(clientid string){
-	fmt.Printf("client id %s connected\n",clientid)
+func (slf *TestTcpService) OnConnected(clientid uint64){
+	fmt.Printf("client id %d connected\n",clientid)
 }
 
 
-func (slf *TestTcpService) OnDisconnected(clientid string){
-	fmt.Printf("client id %s disconnected\n",clientid)
+func (slf *TestTcpService) OnDisconnected(clientid uint64){
+	fmt.Printf("client id %d disconnected\n",clientid)
 }
 
-func (slf *TestTcpService) OnRequest (clientid string,msg proto.Message){
+func (slf *TestTcpService) OnRequest (clientid uint64,msg proto.Message){
 	//解析客户端发过来的数据
 	pReq := msg.(*msgpb.Req)
 	//发送数据给客户端
@@ -1201,5 +1072,4 @@ _
 bp-li
 阿正
 大头
-Now'C
 ```

cluster/cluster.go

@@ -2,12 +2,11 @@ package cluster
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/rpc"
-	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/rpc"
+	"github.com/duanhf2012/origin/service"
 	"strings"
 	"sync"
-	"github.com/duanhf2012/origin/v2/event"
 )
 
 var configDir = "./config/"
@@ -21,25 +20,23 @@ const (
 	Discard NodeStatus = 1 //丢弃
 )
 
-type DiscoveryService struct {
-	MasterNodeId string //要筛选的主结点Id，如果不配置或者配置成0，表示针对所有的主结点
-	NetworkName string  //如果是etcd，指定要筛选的网络名中的服务，不配置，表示所有的网络
-	ServiceList  []string  //只发现的服务列表
+type MasterDiscoveryService struct {
+	MasterNodeId int32 //要筛选的主结点Id，如果不配置或者配置成0，表示针对所有的主结点
+	DiscoveryService  []string  //只发现的服务列表
 }
 
 type NodeInfo struct {
-	NodeId            string
+	NodeId            int
+	NodeName          string
 	Private           bool
 	ListenAddr        string
 	MaxRpcParamLen    uint32   //最大Rpc参数长度
 	CompressBytesLen  int   //超过字节进行压缩的长度
 	ServiceList  	  []string //所有的有序服务列表
 	PublicServiceList []string //对外公开的服务列表
-	DiscoveryService  []DiscoveryService //筛选发现的服务，如果不配置，不进行筛选
+	MasterDiscoveryService  []MasterDiscoveryService //筛选发现的服务，如果不配置，不进行筛选
 	status            NodeStatus
 	Retire bool
-
-	NetworkName string
 }
 
 type NodeRpcInfo struct {
@@ -51,23 +48,19 @@ var cluster Cluster
 
 type Cluster struct {
 	localNodeInfo           NodeInfo    //本结点配置信息
-
-	discoveryInfo DiscoveryInfo //服务发现配置
-	rpcMode RpcMode
-	//masterDiscoveryNodeList []NodeInfo  //配置发现Master结点
+	masterDiscoveryNodeList []NodeInfo  //配置发现Master结点
 	globalCfg               interface{} //全局配置
 
 	localServiceCfg  map[string]interface{} //map[serviceName]配置数据*
 	serviceDiscovery IServiceDiscovery      //服务发现接口
 
+
 	locker         sync.RWMutex                //结点与服务关系保护锁
-	mapRpc           map[string]*NodeRpcInfo    //nodeId
-	mapServiceNode map[string]map[string]struct{} //map[serviceName]map[NodeId]
-
-	callSet rpc.CallSet
-	rpcNats rpc.RpcNats
-	rpcServer rpc.IServer
+	mapRpc           map[int]*NodeRpcInfo    //nodeId
+	//mapIdNode      map[int]NodeInfo            //map[NodeId]NodeInfo
+	mapServiceNode map[string]map[int]struct{} //map[serviceName]map[NodeId]
 
+	rpcServer                rpc.Server
 	rpcEventLocker           sync.RWMutex        //Rpc事件监听保护锁
 	mapServiceListenRpcEvent map[string]struct{} //ServiceName
 	mapServiceListenDiscoveryEvent map[string]struct{} //ServiceName
@@ -85,28 +78,28 @@ func SetServiceDiscovery(serviceDiscovery IServiceDiscovery) {
 	cluster.serviceDiscovery = serviceDiscovery
 }
 
-func (cls *Cluster) Start() error{
-	return cls.rpcServer.Start()
+func (cls *Cluster) Start() {
+	cls.rpcServer.Start(cls.localNodeInfo.ListenAddr, cls.localNodeInfo.MaxRpcParamLen,cls.localNodeInfo.CompressBytesLen)
 }
 
 func (cls *Cluster) Stop() {
-	cls.rpcServer.Stop()
+	cls.serviceDiscovery.OnNodeStop()
 }
 
-func (cls *Cluster) DiscardNode(nodeId string) {
+func (cls *Cluster) DiscardNode(nodeId int) {
 	cls.locker.Lock()
 	nodeInfo, ok := cls.mapRpc[nodeId]
 	bDel := (ok == true) &&  nodeInfo.nodeInfo.status == Discard
 	cls.locker.Unlock()
 
 	if bDel {
-		cls.DelNode(nodeId)
+		cls.DelNode(nodeId, true)
 	}
 }
 
-func (cls *Cluster) DelNode(nodeId string) {
+func (cls *Cluster) DelNode(nodeId int, immediately bool) {
 	//MasterDiscover结点与本地结点不删除
-	if cls.IsOriginMasterDiscoveryNode(nodeId) || nodeId == cls.localNodeInfo.NodeId {
+	if cls.GetMasterDiscoveryNodeInfo(nodeId) != nil || nodeId == cls.localNodeInfo.NodeId {
 		return
 	}
 	cls.locker.Lock()
@@ -117,7 +110,15 @@ func (cls *Cluster) DelNode(nodeId string) {
 		return
 	}
 
-	cls.TriggerDiscoveryEvent(false,nodeId,rpc.nodeInfo.ServiceList)
+	if immediately ==false {
+		//正在连接中不主动断开，只断开没有连接中的
+		if rpc.client.IsConnected() {
+			rpc.nodeInfo.status = Discard
+			log.Info("Discard node",log.Int("nodeId",rpc.nodeInfo.NodeId),log.String("ListenAddr", rpc.nodeInfo.ListenAddr))
+			return
+		}
+	}
+
 	for _, serviceName := range rpc.nodeInfo.ServiceList {
 		cls.delServiceNode(serviceName, nodeId)
 	}
@@ -127,14 +128,18 @@ func (cls *Cluster) DelNode(nodeId string) {
 		rpc.client.Close(false)
 	}
 
-	log.Info("remove node ",log.String("NodeId", rpc.nodeInfo.NodeId),log.String("ListenAddr", rpc.nodeInfo.ListenAddr))
+	log.Info("remove node ",log.Int("NodeId", rpc.nodeInfo.NodeId),log.String("ListenAddr", rpc.nodeInfo.ListenAddr))
 }
 
-func (cls *Cluster) serviceDiscoveryDelNode(nodeId string) {
-	cls.DelNode(nodeId)
+func (cls *Cluster) serviceDiscoveryDelNode(nodeId int, immediately bool) {
+	if nodeId == 0 {
+		return
+	}
+
+	cls.DelNode(nodeId, immediately)
 }
 
-func (cls *Cluster) delServiceNode(serviceName string, nodeId string) {
+func (cls *Cluster) delServiceNode(serviceName string, nodeId int) {
 	if nodeId == cls.localNodeInfo.NodeId {
 		return
 	}
@@ -163,7 +168,6 @@ func (cls *Cluster) serviceDiscoverySetNodeInfo(nodeInfo *NodeInfo) {
 		}
 	}
 
-	cluster.TriggerDiscoveryEvent(true,nodeInfo.NodeId,nodeInfo.PublicServiceList)
 	//再重新组装
 	mapDuplicate := map[string]interface{}{} //预防重复数据
 	for _, serviceName := range nodeInfo.PublicServiceList {
@@ -174,13 +178,13 @@ func (cls *Cluster) serviceDiscoverySetNodeInfo(nodeInfo *NodeInfo) {
 		}
 		mapDuplicate[serviceName] = nil
 		if _, ok := cls.mapServiceNode[serviceName]; ok == false {
-			cls.mapServiceNode[serviceName] = make(map[string]struct{}, 1)
+			cls.mapServiceNode[serviceName] = make(map[int]struct{}, 1)
 		}
 		cls.mapServiceNode[serviceName][nodeInfo.NodeId] = struct{}{}
 	}
 
 	if lastNodeInfo != nil {
-		log.Info("Discovery nodeId",log.String("NodeId", nodeInfo.NodeId),log.Any("services:", nodeInfo.PublicServiceList),log.Bool("Retire",nodeInfo.Retire))
+		log.Info("Discovery nodeId",log.Int("NodeId", nodeInfo.NodeId),log.Any("services:", nodeInfo.PublicServiceList),log.Bool("Retire",nodeInfo.Retire))
 		lastNodeInfo.nodeInfo = *nodeInfo
 		return
 	}
@@ -188,44 +192,24 @@ func (cls *Cluster) serviceDiscoverySetNodeInfo(nodeInfo *NodeInfo) {
 	//不存在时，则建立连接
 	rpcInfo := NodeRpcInfo{}
 	rpcInfo.nodeInfo = *nodeInfo
-
-	if cls.IsNatsMode() {
-		rpcInfo.client = cls.rpcNats.NewNatsClient(nodeInfo.NodeId, cls.GetLocalNodeInfo().NodeId,&cls.callSet,cls.NotifyAllService)
-	}else{
-		rpcInfo.client =rpc.NewRClient(nodeInfo.NodeId, nodeInfo.ListenAddr, nodeInfo.MaxRpcParamLen,cls.localNodeInfo.CompressBytesLen,&cls.callSet,cls.NotifyAllService)
-	}
+	rpcInfo.client =rpc.NewRClient(nodeInfo.NodeId, nodeInfo.ListenAddr, nodeInfo.MaxRpcParamLen,cls.localNodeInfo.CompressBytesLen,cls.triggerRpcEvent)
 	cls.mapRpc[nodeInfo.NodeId] = &rpcInfo
-	if cls.IsNatsMode() == true || cls.discoveryInfo.discoveryType!=OriginType {
-		log.Info("Discovery nodeId and new rpc client",log.String("NodeId", nodeInfo.NodeId),log.Any("services:", nodeInfo.PublicServiceList),log.Bool("Retire",nodeInfo.Retire))
-	}else{
-		log.Info("Discovery nodeId and new rpc client",log.String("NodeId", nodeInfo.NodeId),log.Any("services:", nodeInfo.PublicServiceList),log.Bool("Retire",nodeInfo.Retire),log.String("nodeListenAddr",nodeInfo.ListenAddr))
-	}
+	log.Info("Discovery nodeId and new rpc client",log.Int("NodeId", nodeInfo.NodeId),log.Any("services:", nodeInfo.PublicServiceList),log.Bool("Retire",nodeInfo.Retire),log.String("nodeListenAddr",nodeInfo.ListenAddr))
 }
 
 
-func (cls *Cluster) Init(localNodeId string, setupServiceFun SetupServiceFun) error {
+
+func (cls *Cluster) Init(localNodeId int, setupServiceFun SetupServiceFun) error {
 	//1.初始化配置
 	err := cls.InitCfg(localNodeId)
 	if err != nil {
 		return err
 	}
 
-	cls.callSet.Init()
-	if cls.IsNatsMode() {
-		cls.rpcNats.Init(cls.rpcMode.Nats.NatsUrl,cls.rpcMode.Nats.NoRandomize,cls.GetLocalNodeInfo().NodeId,cls.localNodeInfo.CompressBytesLen,cls,cluster.NotifyAllService)
-		cls.rpcServer = &cls.rpcNats
-	}else{
-		s := &rpc.Server{}
-		s.Init(cls.localNodeInfo.ListenAddr,cls.localNodeInfo.MaxRpcParamLen,cls.localNodeInfo.CompressBytesLen,cls)
-		cls.rpcServer = s
-	}
+	cls.rpcServer.Init(cls)
 
 	//2.安装服务发现结点
-	err = cls.setupDiscovery(localNodeId, setupServiceFun)
-	if err != nil {
-		log.Error("setupDiscovery fail",log.ErrorAttr("err",err))
-		return err
-	}
+	cls.SetupServiceDiscovery(localNodeId, setupServiceFun)
 	service.RegRpcEventFun = cls.RegRpcEvent
 	service.UnRegRpcEventFun = cls.UnRegRpcEvent
 	service.RegDiscoveryServiceEventFun = cls.RegDiscoveryEvent
@@ -239,6 +223,74 @@ func (cls *Cluster) Init(localNodeId string, setupServiceFun SetupServiceFun) er
 	return nil
 }
 
+func (cls *Cluster) checkDynamicDiscovery(localNodeId int) (bool, bool) {
+	var localMaster bool //本结点是否为Master结点
+	var hasMaster bool   //是否配置Master服务
+
+	//遍历所有结点
+	for _, nodeInfo := range cls.masterDiscoveryNodeList {
+		if nodeInfo.NodeId == localNodeId {
+			localMaster = true
+		}
+		hasMaster = true
+	}
+
+	//返回查询结果
+	return localMaster, hasMaster
+}
+
+func (cls *Cluster) AddDynamicDiscoveryService(serviceName string, bPublicService bool) {
+	addServiceList := append([]string{},serviceName)
+	cls.localNodeInfo.ServiceList = append(addServiceList,cls.localNodeInfo.ServiceList...)
+	if bPublicService {
+		cls.localNodeInfo.PublicServiceList = append(cls.localNodeInfo.PublicServiceList, serviceName)
+	}
+
+	if _, ok := cls.mapServiceNode[serviceName]; ok == false {
+		cls.mapServiceNode[serviceName] = map[int]struct{}{}
+	}
+	cls.mapServiceNode[serviceName][cls.localNodeInfo.NodeId] = struct{}{}
+}
+
+func (cls *Cluster) GetDiscoveryNodeList() []NodeInfo {
+	return cls.masterDiscoveryNodeList
+}
+
+func (cls *Cluster) GetMasterDiscoveryNodeInfo(nodeId int) *NodeInfo {
+	for i := 0; i < len(cls.masterDiscoveryNodeList); i++ {
+		if cls.masterDiscoveryNodeList[i].NodeId == nodeId {
+			return &cls.masterDiscoveryNodeList[i]
+		}
+	}
+
+	return nil
+}
+
+func (cls *Cluster) IsMasterDiscoveryNode() bool {
+	return cls.GetMasterDiscoveryNodeInfo(cls.GetLocalNodeInfo().NodeId) != nil
+}
+
+func (cls *Cluster) SetupServiceDiscovery(localNodeId int, setupServiceFun SetupServiceFun) {
+	if cls.serviceDiscovery != nil {
+		return
+	}
+
+	//1.如果没有配置DiscoveryNode配置，则使用默认配置文件发现服务
+	localMaster, hasMaster := cls.checkDynamicDiscovery(localNodeId)
+	if hasMaster == false {
+		cls.serviceDiscovery = &ConfigDiscovery{}
+		return
+	}
+	setupServiceFun(&masterService, &clientService)
+
+	//2.如果为动态服务发现安装本地发现服务
+	cls.serviceDiscovery = getDynamicDiscovery()
+	cls.AddDynamicDiscoveryService(DynamicDiscoveryClientName, true)
+	if localMaster == true {
+		cls.AddDynamicDiscoveryService(DynamicDiscoveryMasterName, false)
+	}
+}
+
 func (cls *Cluster) FindRpcHandler(serviceName string) rpc.IRpcHandler {
 	pService := service.GetService(serviceName)
 	if pService == nil {
@@ -248,7 +300,7 @@ func (cls *Cluster) FindRpcHandler(serviceName string) rpc.IRpcHandler {
 	return pService.GetRpcHandler()
 }
 
-func (cls *Cluster) getRpcClient(nodeId string) (*rpc.Client,bool) {
+func (cls *Cluster) getRpcClient(nodeId int) (*rpc.Client,bool) {
 	c, ok := cls.mapRpc[nodeId]
 	if ok == false {
 		return nil,false
@@ -257,14 +309,14 @@ func (cls *Cluster) getRpcClient(nodeId string) (*rpc.Client,bool) {
 	return c.client,c.nodeInfo.Retire
 }
 
-func (cls *Cluster) GetRpcClient(nodeId string) (*rpc.Client,bool) {
+func (cls *Cluster) GetRpcClient(nodeId int) (*rpc.Client,bool) {
 	cls.locker.RLock()
 	defer cls.locker.RUnlock()
 	return cls.getRpcClient(nodeId)
 }
 
-func GetRpcClient(nodeId string, serviceMethod string,filterRetire bool, clientList []*rpc.Client) (error, int) {
-	if nodeId != rpc.NodeIdNull {
+func GetRpcClient(nodeId int, serviceMethod string,filterRetire bool, clientList []*rpc.Client) (error, int) {
+	if nodeId > 0 {
 		pClient,retire := GetCluster().GetRpcClient(nodeId)
 		if pClient == nil {
 			return fmt.Errorf("cannot find  nodeid %d!", nodeId), 0
@@ -289,16 +341,16 @@ func GetRpcClient(nodeId string, serviceMethod string,filterRetire bool, clientL
 	return GetCluster().GetNodeIdByService(serviceName, clientList, filterRetire)
 }
 
-func GetRpcServer() rpc.IServer {
-	return cluster.rpcServer
+func GetRpcServer() *rpc.Server {
+	return &cluster.rpcServer
 }
 
-func (cls *Cluster) IsNodeConnected(nodeId string) bool {
+func (cls *Cluster) IsNodeConnected(nodeId int) bool {
 	pClient,_ := cls.GetRpcClient(nodeId)
 	return pClient != nil && pClient.IsConnected()
 }
 
-func (cls *Cluster) IsNodeRetire(nodeId string) bool {
+func (cls *Cluster) IsNodeRetire(nodeId int) bool {
 	cls.locker.RLock()
 	defer cls.locker.RUnlock()
 
@@ -306,10 +358,18 @@ func (cls *Cluster) IsNodeRetire(nodeId string) bool {
 	return retire
 }
 
-func (cls *Cluster) NotifyAllService(event event.IEvent){
+
+func (cls *Cluster) triggerRpcEvent(bConnect bool, clientId uint32, nodeId int) {
+	cls.locker.Lock()
+	nodeInfo, ok := cls.mapRpc[nodeId]
+	if ok == false || nodeInfo.client == nil || nodeInfo.client.GetClientId() != clientId {
+		cls.locker.Unlock()
+		return
+	}
+	cls.locker.Unlock()
+
 	cls.rpcEventLocker.Lock()
 	defer cls.rpcEventLocker.Unlock()
-
 	for serviceName, _ := range cls.mapServiceListenRpcEvent {
 		ser := service.GetService(serviceName)
 		if ser == nil {
@@ -317,11 +377,14 @@ func (cls *Cluster) NotifyAllService(event event.IEvent){
 			continue
 		}
 
-		ser.(service.IModule).NotifyEvent(event)
+		var eventData service.RpcConnEvent
+		eventData.IsConnect = bConnect
+		eventData.NodeId = nodeId
+		ser.(service.IModule).NotifyEvent(&eventData)
 	}
 }
 
-func (cls *Cluster) TriggerDiscoveryEvent(bDiscovery bool, nodeId string, serviceName []string) {
+func (cls *Cluster) TriggerDiscoveryEvent(bDiscovery bool, nodeId int, serviceName []string) {
 	cls.rpcEventLocker.Lock()
 	defer cls.rpcEventLocker.Unlock()
 
@@ -380,7 +443,7 @@ func (cls *Cluster) UnReDiscoveryEvent(serviceName string) {
 
 
 
-func HasService(nodeId string, serviceName string) bool {
+func HasService(nodeId int, serviceName string) bool {
 	cluster.locker.RLock()
 	defer cluster.locker.RUnlock()
 
@@ -393,7 +456,7 @@ func HasService(nodeId string, serviceName string) bool {
 	return false
 }
 
-func GetNodeByServiceName(serviceName string) map[string]struct{} {
+func GetNodeByServiceName(serviceName string) map[int]struct{} {
 	cluster.locker.RLock()
 	defer cluster.locker.RUnlock()
 
@@ -402,7 +465,7 @@ func GetNodeByServiceName(serviceName string) map[string]struct{} {
 		return nil
 	}
 
-	mapNodeId := map[string]struct{}{}
+	mapNodeId := map[int]struct{}{}
 	for nodeId,_ := range mapNode {
 		mapNodeId[nodeId] = struct{}{}
 	}
@@ -414,7 +477,7 @@ func (cls *Cluster) GetGlobalCfg() interface{} {
 	return cls.globalCfg
 }
 
-func (cls *Cluster) GetNodeInfo(nodeId string) (NodeInfo,bool) {
+func (cls *Cluster) GetNodeInfo(nodeId int) (NodeInfo,bool) {
 	cls.locker.RLock()
 	defer cls.locker.RUnlock()
 
@@ -425,26 +488,3 @@ func (cls *Cluster) GetNodeInfo(nodeId string) (NodeInfo,bool) {
 
 	return nodeInfo.nodeInfo,true
 }
-
-func (dc *Cluster) CanDiscoveryService(fromMasterNodeId string,serviceName string) bool{
-	canDiscovery := true
-
-	for i:=0;i<len(dc.GetLocalNodeInfo().DiscoveryService);i++{
-		masterNodeId := dc.GetLocalNodeInfo().DiscoveryService[i].MasterNodeId
-		//无效的配置，则跳过
-		if masterNodeId == rpc.NodeIdNull && len(dc.GetLocalNodeInfo().DiscoveryService[i].ServiceList)==0 {
-			continue
-		}
-
-		canDiscovery = false
-		if masterNodeId == fromMasterNodeId || masterNodeId == rpc.NodeIdNull {
-			for _,discoveryService := range dc.GetLocalNodeInfo().DiscoveryService[i].ServiceList {
-				if discoveryService == serviceName {
-					return true
-				}
-			}
-		}
-	}
-
-	return canDiscovery
-}

cluster/configdiscovery.go

@@ -1,21 +1,19 @@
 package cluster
 
-import "github.com/duanhf2012/origin/v2/rpc"
-
 type ConfigDiscovery struct {
-	funDelNode FunDelNode
-	funSetNode FunSetNode
-	localNodeId string
+	funDelService FunDelNode
+	funSetService FunSetNodeInfo
+	localNodeId int
 }
 
 
-func (discovery *ConfigDiscovery) InitDiscovery(localNodeId string,funDelNode FunDelNode,funSetNode FunSetNode) error{
+func (discovery *ConfigDiscovery) InitDiscovery(localNodeId int,funDelNode FunDelNode,funSetNodeInfo FunSetNodeInfo) error{
 	discovery.localNodeId = localNodeId
-	discovery.funDelNode = funDelNode
-	discovery.funSetNode = funSetNode
-	
+	discovery.funDelService = funDelNode
+	discovery.funSetService = funSetNodeInfo
+
 	//解析本地其他服务配置
-	_,nodeInfoList,_,err := GetCluster().readLocalClusterConfig(rpc.NodeIdNull)
+	_,nodeInfoList,err := GetCluster().readLocalClusterConfig(0)
 	if err != nil {
 		return err
 	}
@@ -25,10 +23,12 @@ func (discovery *ConfigDiscovery) InitDiscovery(localNodeId string,funDelNode Fu
 			continue
 		}
 
-		discovery.funSetNode(&nodeInfo)
+		discovery.funSetService(&nodeInfo)
 	}
 
 	return nil
 }
 
+func (discovery *ConfigDiscovery) OnNodeStop(){
+}
 

cluster/discovery.go

@@ -1,71 +0,0 @@
-package cluster
-
-import (
-	"errors"
-	"github.com/duanhf2012/origin/v2/service"
-)
-
-func (cls *Cluster) setupDiscovery(localNodeId string, setupServiceFun SetupServiceFun) error{
-	if cls.discoveryInfo.getDiscoveryType() == OriginType { //origin类型服务发现
-		return cls.setupOriginDiscovery(localNodeId,setupServiceFun)
-	}else if cls.discoveryInfo.getDiscoveryType() ==  EtcdType{//etcd类型服务发现
-		return cls.setupEtcdDiscovery(localNodeId,setupServiceFun)
-	}
-
-	return cls.setupConfigDiscovery(localNodeId,setupServiceFun)
-}
-
-func (cls *Cluster) setupOriginDiscovery(localNodeId string, setupServiceFun SetupServiceFun) error{
-	if cls.serviceDiscovery != nil {
-		return errors.New("service discovery has been setup")
-	}
-
-	//1.如果没有配置DiscoveryNode配置，则使用默认配置文件发现服务
-	localMaster, hasMaster := cls.checkOriginDiscovery(localNodeId)
-	if hasMaster == false {
-		return errors.New("no master node config")
-	}
-
-	cls.serviceDiscovery = getOriginDiscovery()
-	//2.如果为动态服务发现安装本地发现服务
-	if localMaster == true {
-		setupServiceFun(&masterService)
-		cls.AddDiscoveryService(OriginDiscoveryMasterName, false)
-	}
-
-	setupServiceFun(&clientService)
-	cls.AddDiscoveryService(OriginDiscoveryClientName, true)
-
-
-	return nil
-}
-
-func (cls *Cluster) setupEtcdDiscovery(localNodeId string, setupServiceFun SetupServiceFun) error{
-	if cls.serviceDiscovery != nil {
-		return errors.New("service discovery has been setup")
-	}
-
-	//setup etcd service
-	cls.serviceDiscovery = getEtcdDiscovery()
-	setupServiceFun(cls.serviceDiscovery.(service.IService))
-	
-	cls.AddDiscoveryService(cls.serviceDiscovery.(service.IService).GetName(),false)
-	return nil
-}
-
-func (cls *Cluster) setupConfigDiscovery(localNodeId string, setupServiceFun SetupServiceFun) error{
-	if cls.serviceDiscovery != nil {
-		return errors.New("service discovery has been setup")
-	}
-
-	cls.serviceDiscovery = &ConfigDiscovery{}
-	return nil
-}
-
-func (cls *Cluster) GetOriginDiscovery() *OriginDiscovery {
-	return cls.discoveryInfo.Origin
-}
-
-func (cls *Cluster) GetEtcdDiscovery() *EtcdDiscovery {
-	return cls.discoveryInfo.Etcd
-}

cluster/dynamicdiscovery.go

@@ -0,0 +1,485 @@
+package cluster
+
+import (
+	"errors"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/rpc"
+	"github.com/duanhf2012/origin/service"
+	"time"
+	"github.com/duanhf2012/origin/util/timer"
+	"google.golang.org/protobuf/proto"
+)
+
+const DynamicDiscoveryMasterName = "DiscoveryMaster"
+const DynamicDiscoveryClientName = "DiscoveryClient"
+const RegServiceDiscover = DynamicDiscoveryMasterName + ".RPC_RegServiceDiscover"
+const SubServiceDiscover = DynamicDiscoveryClientName + ".RPC_SubServiceDiscover"
+const AddSubServiceDiscover = DynamicDiscoveryMasterName + ".RPC_AddSubServiceDiscover"
+const NodeRetireRpcMethod = DynamicDiscoveryMasterName+".RPC_NodeRetire"
+
+type DynamicDiscoveryMaster struct {
+	service.Service
+
+	mapNodeInfo map[int32]struct{}
+	nodeInfo    []*rpc.NodeInfo
+}
+
+type DynamicDiscoveryClient struct {
+	service.Service
+
+	funDelService FunDelNode
+	funSetService FunSetNodeInfo
+	localNodeId   int
+
+	mapDiscovery map[int32]map[int32]struct{} //map[masterNodeId]map[nodeId]struct{}
+	bRetire bool
+}
+
+var masterService DynamicDiscoveryMaster
+var clientService DynamicDiscoveryClient
+
+func getDynamicDiscovery() IServiceDiscovery {
+	return &clientService
+}
+
+func init() {
+	masterService.SetName(DynamicDiscoveryMasterName)
+	clientService.SetName(DynamicDiscoveryClientName)
+}
+
+func (ds *DynamicDiscoveryMaster) isRegNode(nodeId int32) bool {
+	_, ok := ds.mapNodeInfo[nodeId]
+	return ok
+}
+
+func (ds *DynamicDiscoveryMaster) updateNodeInfo(nInfo *rpc.NodeInfo) {
+	if _,ok:= ds.mapNodeInfo[nInfo.NodeId];ok == false {
+		return
+	}
+
+	nodeInfo := proto.Clone(nInfo).(*rpc.NodeInfo)
+	for i:=0;i<len(ds.nodeInfo);i++ {
+		if ds.nodeInfo[i].NodeId == nodeInfo.NodeId {
+			ds.nodeInfo[i]  = nodeInfo
+			break
+		}
+	}
+}
+
+func (ds *DynamicDiscoveryMaster) addNodeInfo(nInfo *rpc.NodeInfo) {
+	if len(nInfo.PublicServiceList) == 0 {
+		return
+	}
+
+	_, ok := ds.mapNodeInfo[nInfo.NodeId]
+	if ok == true {
+		return
+	}
+	ds.mapNodeInfo[nInfo.NodeId] = struct{}{}
+
+	nodeInfo := proto.Clone(nInfo).(*rpc.NodeInfo)
+	ds.nodeInfo = append(ds.nodeInfo, nodeInfo)
+}
+
+func (ds *DynamicDiscoveryMaster) removeNodeInfo(nodeId int32) {
+	if _,ok:= ds.mapNodeInfo[nodeId];ok == false {
+		return
+	}
+
+	for i:=0;i<len(ds.nodeInfo);i++ {
+		if ds.nodeInfo[i].NodeId == nodeId {
+			ds.nodeInfo = append(ds.nodeInfo[:i],ds.nodeInfo[i+1:]...)
+			break
+		}
+	}
+
+	delete(ds.mapNodeInfo,nodeId)
+}
+
+func (ds *DynamicDiscoveryMaster) OnInit() error {
+	ds.mapNodeInfo = make(map[int32]struct{}, 20)
+	ds.RegRpcListener(ds)
+
+	return nil
+}
+
+func (ds *DynamicDiscoveryMaster) OnStart() {
+	var nodeInfo rpc.NodeInfo
+	localNodeInfo := cluster.GetLocalNodeInfo()
+	nodeInfo.NodeId = int32(localNodeInfo.NodeId)
+	nodeInfo.NodeName = localNodeInfo.NodeName
+	nodeInfo.ListenAddr = localNodeInfo.ListenAddr
+	nodeInfo.PublicServiceList = localNodeInfo.PublicServiceList
+	nodeInfo.MaxRpcParamLen = localNodeInfo.MaxRpcParamLen
+	nodeInfo.Private = localNodeInfo.Private
+	nodeInfo.Retire = localNodeInfo.Retire
+
+	ds.addNodeInfo(&nodeInfo)
+}
+
+func (ds *DynamicDiscoveryMaster) OnNodeConnected(nodeId int) {
+	//没注册过结点不通知
+	if ds.isRegNode(int32(nodeId)) == false {
+		return
+	}
+
+	//向它发布所有服务列表信息
+	var notifyDiscover rpc.SubscribeDiscoverNotify
+	notifyDiscover.IsFull = true
+	notifyDiscover.NodeInfo = ds.nodeInfo
+	notifyDiscover.MasterNodeId = int32(cluster.GetLocalNodeInfo().NodeId)
+
+	ds.GoNode(nodeId, SubServiceDiscover, &notifyDiscover)
+}
+
+func (ds *DynamicDiscoveryMaster) OnNodeDisconnect(nodeId int) {
+	if ds.isRegNode(int32(nodeId)) == false {
+		return
+	}
+
+	ds.removeNodeInfo(int32(nodeId))
+
+	var notifyDiscover rpc.SubscribeDiscoverNotify
+	notifyDiscover.MasterNodeId = int32(cluster.GetLocalNodeInfo().NodeId)
+	notifyDiscover.DelNodeId = int32(nodeId)
+	//删除结点
+	cluster.DelNode(nodeId, true)
+
+	//无注册过的结点不广播，避免非当前Master网络中的连接断开时通知到本网络
+	ds.CastGo(SubServiceDiscover, &notifyDiscover)
+}
+
+func (ds *DynamicDiscoveryMaster) RpcCastGo(serviceMethod string, args interface{}) {
+	for nodeId, _ := range ds.mapNodeInfo {
+		ds.GoNode(int(nodeId), serviceMethod, args)
+	}
+}
+
+func (ds *DynamicDiscoveryMaster) RPC_NodeRetire(req *rpc.NodeRetireReq, res *rpc.Empty) error {
+	log.Info("node is retire",log.Int32("nodeId",req.NodeInfo.NodeId),log.Bool("retire",req.NodeInfo.Retire))
+
+	ds.updateNodeInfo(req.NodeInfo)
+
+	var notifyDiscover rpc.SubscribeDiscoverNotify
+	notifyDiscover.MasterNodeId = int32(cluster.GetLocalNodeInfo().NodeId)
+	notifyDiscover.NodeInfo = append(notifyDiscover.NodeInfo, req.NodeInfo)
+	ds.RpcCastGo(SubServiceDiscover, &notifyDiscover)
+
+	return nil
+}
+
+// 收到注册过来的结点
+func (ds *DynamicDiscoveryMaster) RPC_RegServiceDiscover(req *rpc.ServiceDiscoverReq, res *rpc.Empty) error {
+	if req.NodeInfo == nil {
+		err := errors.New("RPC_RegServiceDiscover req is error.")
+		log.Error(err.Error())
+
+		return err
+	}
+
+	//广播给其他所有结点
+	var notifyDiscover rpc.SubscribeDiscoverNotify
+	notifyDiscover.MasterNodeId = int32(cluster.GetLocalNodeInfo().NodeId)
+	notifyDiscover.NodeInfo = append(notifyDiscover.NodeInfo, req.NodeInfo)
+	ds.RpcCastGo(SubServiceDiscover, &notifyDiscover)
+
+	//存入本地
+	ds.addNodeInfo(req.NodeInfo)
+
+	//初始化结点信息
+	var nodeInfo NodeInfo
+	nodeInfo.NodeId = int(req.NodeInfo.NodeId)
+	nodeInfo.NodeName = req.NodeInfo.NodeName
+	nodeInfo.Private = req.NodeInfo.Private
+	nodeInfo.ServiceList = req.NodeInfo.PublicServiceList
+	nodeInfo.PublicServiceList = req.NodeInfo.PublicServiceList
+	nodeInfo.ListenAddr = req.NodeInfo.ListenAddr
+	nodeInfo.MaxRpcParamLen = req.NodeInfo.MaxRpcParamLen
+	nodeInfo.Retire = req.NodeInfo.Retire
+
+	//主动删除已经存在的结点,确保先断开，再连接
+	cluster.serviceDiscoveryDelNode(nodeInfo.NodeId, true)
+
+	//加入到本地Cluster模块中，将连接该结点
+	cluster.serviceDiscoverySetNodeInfo(&nodeInfo)
+
+	return nil
+}
+
+func (dc *DynamicDiscoveryClient) OnInit() error {
+	dc.RegRpcListener(dc)
+	dc.mapDiscovery = map[int32]map[int32]struct{}{}
+	return nil
+}
+
+func (dc *DynamicDiscoveryClient) addMasterNode(masterNodeId int32, nodeId int32) {
+	_, ok := dc.mapDiscovery[masterNodeId]
+	if ok == false {
+		dc.mapDiscovery[masterNodeId] = map[int32]struct{}{}
+	}
+	dc.mapDiscovery[masterNodeId][nodeId] = struct{}{}
+}
+
+func (dc *DynamicDiscoveryClient) removeMasterNode(masterNodeId int32, nodeId int32) {
+	mapNodeId, ok := dc.mapDiscovery[masterNodeId]
+	if ok == false {
+		return
+	}
+
+	delete(mapNodeId, nodeId)
+}
+
+func (dc *DynamicDiscoveryClient) findNodeId(nodeId int32) bool {
+	for _, mapNodeId := range dc.mapDiscovery {
+		_, ok := mapNodeId[nodeId]
+		if ok == true {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (dc *DynamicDiscoveryClient) OnStart() {
+	//2.添加并连接发现主结点
+	dc.addDiscoveryMaster()
+}
+
+func (dc *DynamicDiscoveryClient) addDiscoveryMaster() {
+	discoveryNodeList := cluster.GetDiscoveryNodeList()
+	for i := 0; i < len(discoveryNodeList); i++ {
+		if discoveryNodeList[i].NodeId == cluster.GetLocalNodeInfo().NodeId {
+			continue
+		}
+		dc.funSetService(&discoveryNodeList[i])
+	}
+}
+
+func (dc *DynamicDiscoveryClient) fullCompareDiffNode(masterNodeId int32, mapNodeInfo map[int32]*rpc.NodeInfo) []int32 {
+	if mapNodeInfo == nil {
+		return nil
+	}
+
+	diffNodeIdSlice := make([]int32, 0, len(mapNodeInfo))
+	mapNodeId := map[int32]struct{}{}
+	mapNodeId, ok := dc.mapDiscovery[masterNodeId]
+	if ok == false {
+		return nil
+	}
+
+	//本地任何Master都不存在的，放到diffNodeIdSlice
+	for nodeId, _ := range mapNodeId {
+		_, ok := mapNodeInfo[nodeId]
+		if ok == false {
+			diffNodeIdSlice = append(diffNodeIdSlice, nodeId)
+		}
+	}
+
+	return diffNodeIdSlice
+}
+
+//订阅发现的服务通知
+func (dc *DynamicDiscoveryClient) RPC_SubServiceDiscover(req *rpc.SubscribeDiscoverNotify) error {
+	mapNodeInfo := map[int32]*rpc.NodeInfo{}
+	for _, nodeInfo := range req.NodeInfo {
+		//不对本地结点或者不存在任何公开服务的结点
+		if int(nodeInfo.NodeId) == dc.localNodeId {
+			continue
+		}
+
+		if cluster.IsMasterDiscoveryNode() == false && len(nodeInfo.PublicServiceList) == 1 &&
+			nodeInfo.PublicServiceList[0] == DynamicDiscoveryClientName {
+			continue
+		}
+
+		//遍历所有的公开服务，并筛选之
+		for _, serviceName := range nodeInfo.PublicServiceList {
+			nInfo := mapNodeInfo[nodeInfo.NodeId]
+			if nInfo == nil {
+				nInfo = &rpc.NodeInfo{}
+				nInfo.NodeId = nodeInfo.NodeId
+				nInfo.NodeName = nodeInfo.NodeName
+				nInfo.ListenAddr = nodeInfo.ListenAddr
+				nInfo.MaxRpcParamLen = nodeInfo.MaxRpcParamLen
+				nInfo.Retire = nodeInfo.Retire
+				nInfo.Private = nodeInfo.Private
+
+				mapNodeInfo[nodeInfo.NodeId] = nInfo
+			}
+
+			nInfo.PublicServiceList = append(nInfo.PublicServiceList, serviceName)
+		}
+	}
+
+	//如果为完整同步，则找出差异的结点
+	var willDelNodeId []int32
+	if req.IsFull == true {
+		diffNode := dc.fullCompareDiffNode(req.MasterNodeId, mapNodeInfo)
+		if len(diffNode) > 0 {
+			willDelNodeId = append(willDelNodeId, diffNode...)
+		}
+	}
+
+	//指定删除结点
+	if req.DelNodeId > 0 && req.DelNodeId != int32(dc.localNodeId) {
+		willDelNodeId = append(willDelNodeId, req.DelNodeId)
+	}
+
+	//删除不必要的结点
+	for _, nodeId := range willDelNodeId {
+		cluster.TriggerDiscoveryEvent(false,int(nodeId),nil)
+		dc.removeMasterNode(req.MasterNodeId, int32(nodeId))
+		if dc.findNodeId(nodeId) == false {
+			dc.funDelService(int(nodeId), false)
+		}
+	}
+
+	//设置新结点
+	for _, nodeInfo := range mapNodeInfo {
+		bSet := dc.setNodeInfo(req.MasterNodeId,nodeInfo)
+		if bSet == false {
+			continue
+		}
+
+		cluster.TriggerDiscoveryEvent(true,int(nodeInfo.NodeId),nodeInfo.PublicServiceList)
+	}
+
+	return nil
+}
+
+func (dc *DynamicDiscoveryClient) isDiscoverNode(nodeId int) bool {
+	for i := 0; i < len(cluster.masterDiscoveryNodeList); i++ {
+		if cluster.masterDiscoveryNodeList[i].NodeId == nodeId {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (dc *DynamicDiscoveryClient) OnNodeConnected(nodeId int) {
+	dc.regServiceDiscover(nodeId)
+}
+
+func (dc *DynamicDiscoveryClient) OnRetire(){
+	dc.bRetire = true
+
+	masterNodeList := cluster.GetDiscoveryNodeList()
+	for i:=0;i<len(masterNodeList);i++{
+		var nodeRetireReq rpc.NodeRetireReq
+
+		nodeRetireReq.NodeInfo = &rpc.NodeInfo{}
+		nodeRetireReq.NodeInfo.NodeId = int32(cluster.localNodeInfo.NodeId)
+		nodeRetireReq.NodeInfo.NodeName = cluster.localNodeInfo.NodeName
+		nodeRetireReq.NodeInfo.ListenAddr = cluster.localNodeInfo.ListenAddr
+		nodeRetireReq.NodeInfo.MaxRpcParamLen = cluster.localNodeInfo.MaxRpcParamLen
+		nodeRetireReq.NodeInfo.PublicServiceList =  cluster.localNodeInfo.PublicServiceList
+		nodeRetireReq.NodeInfo.Retire = dc.bRetire
+		nodeRetireReq.NodeInfo.Private = cluster.localNodeInfo.Private
+
+		err := dc.GoNode(int(masterNodeList[i].NodeId),NodeRetireRpcMethod,&nodeRetireReq)
+		if err!= nil {
+			log.Error("call "+NodeRetireRpcMethod+" is fail",log.ErrorAttr("err",err))
+		}
+	}
+}
+
+func (dc *DynamicDiscoveryClient) regServiceDiscover(nodeId int){
+	nodeInfo := cluster.GetMasterDiscoveryNodeInfo(nodeId)
+	if nodeInfo == nil {
+		return
+	}
+
+	var req rpc.ServiceDiscoverReq
+	req.NodeInfo = &rpc.NodeInfo{}
+	req.NodeInfo.NodeId = int32(cluster.localNodeInfo.NodeId)
+	req.NodeInfo.NodeName = cluster.localNodeInfo.NodeName
+	req.NodeInfo.ListenAddr = cluster.localNodeInfo.ListenAddr
+	req.NodeInfo.MaxRpcParamLen = cluster.localNodeInfo.MaxRpcParamLen
+	req.NodeInfo.PublicServiceList =  cluster.localNodeInfo.PublicServiceList
+	req.NodeInfo.Retire = dc.bRetire
+	req.NodeInfo.Private = cluster.localNodeInfo.Private
+
+	//向Master服务同步本Node服务信息
+	err := dc.AsyncCallNode(nodeId, RegServiceDiscover, &req, func(res *rpc.Empty, err error) {
+		if err != nil {
+			log.Error("call "+RegServiceDiscover+" is fail :"+ err.Error())
+			dc.AfterFunc(time.Second*3, func(timer *timer.Timer) {
+				dc.regServiceDiscover(nodeId)
+			})
+
+			return
+		}
+	})
+	if err != nil {
+		log.Error("call "+ RegServiceDiscover+" is fail :"+ err.Error())
+	}
+}
+
+func (dc *DynamicDiscoveryClient) canDiscoveryService(fromMasterNodeId int32,serviceName string) bool{
+	canDiscovery := true
+
+	for i:=0;i<len(cluster.GetLocalNodeInfo().MasterDiscoveryService);i++{
+		masterNodeId := cluster.GetLocalNodeInfo().MasterDiscoveryService[i].MasterNodeId
+
+		if masterNodeId == fromMasterNodeId || masterNodeId == 0 {
+			canDiscovery = false
+
+			for _,discoveryService := range cluster.GetLocalNodeInfo().MasterDiscoveryService[i].DiscoveryService {
+				if discoveryService == serviceName {
+					return true
+				}
+			}
+		}
+	}
+
+	return canDiscovery
+}
+
+func (dc *DynamicDiscoveryClient) setNodeInfo(masterNodeId int32,nodeInfo *rpc.NodeInfo) bool{
+	if nodeInfo == nil || nodeInfo.Private == true || int(nodeInfo.NodeId) == dc.localNodeId {
+		return false
+	}
+
+	//筛选关注的服务
+	var discoverServiceSlice = make([]string, 0, 24)
+	for _, pubService := range nodeInfo.PublicServiceList {
+		if dc.canDiscoveryService(masterNodeId,pubService) == true {
+			discoverServiceSlice = append(discoverServiceSlice,pubService)
+		}
+	}
+
+	if len(discoverServiceSlice) == 0 {
+		return false
+	}
+
+	var nInfo NodeInfo
+	nInfo.ServiceList = discoverServiceSlice
+	nInfo.PublicServiceList = discoverServiceSlice
+	nInfo.NodeId = int(nodeInfo.NodeId)
+	nInfo.NodeName = nodeInfo.NodeName
+	nInfo.ListenAddr = nodeInfo.ListenAddr
+	nInfo.MaxRpcParamLen = nodeInfo.MaxRpcParamLen
+	nInfo.Retire = nodeInfo.Retire
+	nInfo.Private = nodeInfo.Private
+
+	dc.funSetService(&nInfo)
+
+	return true
+}
+
+func (dc *DynamicDiscoveryClient) OnNodeDisconnect(nodeId int) {
+	//将Discard结点清理
+	cluster.DiscardNode(nodeId)
+}
+
+func (dc *DynamicDiscoveryClient) InitDiscovery(localNodeId int, funDelNode FunDelNode, funSetNodeInfo FunSetNodeInfo) error {
+	dc.localNodeId = localNodeId
+	dc.funDelService = funDelNode
+	dc.funSetService = funSetNodeInfo
+
+	return nil
+}
+
+func (dc *DynamicDiscoveryClient) OnNodeStop() {
+}

cluster/etcddiscovery.go

@@ -1,521 +0,0 @@
-package cluster
-
-
-import (
-	"github.com/duanhf2012/origin/v2/event"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/rpc"
-	"github.com/duanhf2012/origin/v2/service"
-	"github.com/duanhf2012/origin/v2/util/timer"
-	"go.etcd.io/etcd/api/v3/mvccpb"
-	"go.etcd.io/etcd/client/v3"
-	"google.golang.org/protobuf/proto"
-	"time"
-
-	"context"
-	"errors"
-	"fmt"
-	"go.uber.org/zap"
-	"path"
-	"runtime"
-	"strings"
-	"sync/atomic"
-)
-
-const originDir = "/origin"
-const testKey = originDir+"/_inner/_test_7501f3ed-b716-44c2-0090-fc1ed0166d7a"
-
-type etcdClientInfo struct {
-	watchKeys []string
-	leaseID clientv3.LeaseID
-	keepAliveChan <-chan *clientv3.LeaseKeepAliveResponse
-}
-
-type EtcdDiscoveryService struct {
-	service.Service
-	funDelNode FunDelNode
-	funSetNode FunSetNode
-	localNodeId   string
-
-	byteLocalNodeInfo string
-	mapClient map[*clientv3.Client]*etcdClientInfo
-	isClose int32
-	bRetire bool
-	mapDiscoveryNodeId map[string]map[string]struct{} //map[networkName]map[nodeId]
-}
-
-func getEtcdDiscovery() (IServiceDiscovery) {
-	etcdDiscovery := &EtcdDiscoveryService{}
-	return etcdDiscovery
-}
-
-func (ed *EtcdDiscoveryService) InitDiscovery(localNodeId string,funDelNode FunDelNode,funSetNode FunSetNode) error {
-	ed.localNodeId = localNodeId
-
-	ed.funDelNode = funDelNode
-	ed.funSetNode = funSetNode
-
-	return nil
-}
-
-const(
-	eeGets = 0
-	eePut = 1
-	eeDelete = 2
-)
-
-type etcdDiscoveryEvent struct {
-	typ int
-	watchKey string
-	Kvs []*mvccpb.KeyValue
-}
-
-func (ee *etcdDiscoveryEvent) GetEventType() event.EventType{
-	return event.Sys_Event_EtcdDiscovery
-}
-
-func (ed *EtcdDiscoveryService) OnInit() error {
-	ed.mapClient = make(map[*clientv3.Client]*etcdClientInfo,1)
-	ed.mapDiscoveryNodeId = make(map[string]map[string]struct{})
-
-	ed.GetEventProcessor().RegEventReceiverFunc(event.Sys_Event_EtcdDiscovery, ed.GetEventHandler(), ed.OnEtcdDiscovery)
-
-	err := ed.marshalNodeInfo()
-	if err != nil {
-		return err
-	}
-
-	etcdDiscoveryCfg := cluster.GetEtcdDiscovery()
-	if etcdDiscoveryCfg == nil {
-		return errors.New("etcd discovery config is nil.")
-	}
-
-	for i:=0;i<len(etcdDiscoveryCfg.EtcdList);i++{
-		client, cerr := clientv3.New(clientv3.Config{
-			Endpoints:  etcdDiscoveryCfg.EtcdList[i].Endpoints,
-			DialTimeout: etcdDiscoveryCfg.DialTimeoutMillisecond,
-			Logger: zap.NewNop(),
-		})
-
-		if cerr != nil {
-			log.Error("etcd discovery init fail",log.ErrorAttr("err",cerr))
-			return cerr
-		}
-
-		ctx,_:=context.WithTimeout(context.Background(),time.Second*3)
-		_,err = client.Leases(ctx)
-		if err != nil {
-			log.Error("etcd discovery init fail",log.Any("endpoint",etcdDiscoveryCfg.EtcdList[i].Endpoints),log.ErrorAttr("err",err))
-			return err
-		}
-
-		ec := &etcdClientInfo{}
-		for _, networkName := range etcdDiscoveryCfg.EtcdList[i].NetworkName {
-			ec.watchKeys = append(ec.watchKeys,fmt.Sprintf("%s/%s",originDir,networkName))
-		}
-
-		ed.mapClient[client] = ec
-	}
-
-	return nil
-}
-
-func (ed *EtcdDiscoveryService) getRegisterKey(watchkey string) string{
-	return watchkey+"/"+ed.localNodeId
-}
-
-func (ed *EtcdDiscoveryService) registerServiceByClient(client *clientv3.Client,etcdClient *etcdClientInfo) {
-	// 创建租约
-	var err error
-	var resp *clientv3.LeaseGrantResponse
-	resp, err = client.Grant(context.Background(), cluster.GetEtcdDiscovery().TTLSecond)
-	if err != nil {
-		log.Error("etcd registerService fail",log.ErrorAttr("err",err))
-		ed.tryRegisterService(client,etcdClient)
-		return
-	}
-
-	etcdClient.leaseID = resp.ID
-	for _,watchKey:= range etcdClient.watchKeys {
-		// 注册服务节点到 etcd
-		_, err = client.Put(context.Background(), ed.getRegisterKey(watchKey), ed.byteLocalNodeInfo, clientv3.WithLease(resp.ID))
-		if err != nil {
-			log.Error("etcd Put fail",log.ErrorAttr("err",err))
-			ed.tryRegisterService(client,etcdClient)
-			return
-		}
-	}
-
-	etcdClient.keepAliveChan,err = client.KeepAlive(context.Background(), etcdClient.leaseID)
-	if err != nil {
-		log.Error("etcd KeepAlive fail",log.ErrorAttr("err",err))
-		ed.tryRegisterService(client,etcdClient)
-		return
-	}
-
-	go func() {
-		for {
-			select {
-			case _, ok := <-etcdClient.keepAliveChan:
-				//log.Debug("ok",log.Any("addr",client.Endpoints()))
-				if !ok {
-					log.Error("etcd keepAliveChan fail",log.Any("watchKeys",etcdClient.watchKeys))
-					ed.tryRegisterService(client,etcdClient)
-					return
-				}
-			}
-		}
-	}()
-}
-
-
-func (ed *EtcdDiscoveryService) tryRegisterService(client *clientv3.Client,etcdClient *etcdClientInfo){
-	if ed.isStop() {
-		return
-	}
-
-	ed.AfterFunc(time.Second*3, func(t *timer.Timer) {
-		ed.registerServiceByClient(client,etcdClient)
-	})
-}
-
-func (ed *EtcdDiscoveryService) tryWatch(client *clientv3.Client,etcdClient *etcdClientInfo) {
-	if ed.isStop() {
-		return
-	}
-	ed.AfterFunc(time.Second*3, func(t *timer.Timer) {
-		ed.watchByClient(client,etcdClient)
-	})
-}
-
-func (ed *EtcdDiscoveryService) tryLaterRetire() {
-	ed.AfterFunc(time.Second, func(*timer.Timer) {
-		if ed.retire() != nil {
-			ed.tryLaterRetire()
-		}
-	})
-}
-
-func (ed *EtcdDiscoveryService) retire() error{
-	//从etcd中更新
-	for c,ec := range ed.mapClient {
-		for _, watchKey := range ec.watchKeys {
-			// 注册服务节点到 etcd
-			_, err := c.Put(context.Background(), ed.getRegisterKey(watchKey), ed.byteLocalNodeInfo, clientv3.WithLease(ec.leaseID))
-			if err != nil {
-				log.Error("etcd Put fail", log.ErrorAttr("err", err))
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-func (ed *EtcdDiscoveryService) OnRetire(){
-	ed.bRetire = true
-	ed.marshalNodeInfo()
-
-	if ed.retire()!= nil {
-		ed.tryLaterRetire()
-	}
-}
-
-func (ed *EtcdDiscoveryService) OnRelease(){
-	atomic.StoreInt32(&ed.isClose,1)
-	ed.close()
-}
-
-func (ed *EtcdDiscoveryService) isStop() bool{
-	return atomic.LoadInt32(&ed.isClose) == 1
-}
-
-func (nd *EtcdDiscoveryService) OnStart() {
-	for c, ec := range nd.mapClient {
-		nd.tryRegisterService(c,ec)
-		nd.tryWatch(c,ec)
-	}
-}
-
-func (ed *EtcdDiscoveryService) marshalNodeInfo() error{
-	nInfo := cluster.GetLocalNodeInfo()
-	var nodeInfo rpc.NodeInfo
-	nodeInfo.NodeId = nInfo.NodeId
-	nodeInfo.ListenAddr = nInfo.ListenAddr
-	nodeInfo.Retire = ed.bRetire
-	nodeInfo.PublicServiceList = nInfo.PublicServiceList
-	nodeInfo.MaxRpcParamLen = nInfo.MaxRpcParamLen
-
-	byteLocalNodeInfo,err := proto.Marshal(&nodeInfo)
-	if err ==nil{
-		ed.byteLocalNodeInfo = string(byteLocalNodeInfo)
-	}
-
-	return err
-}
-
-func (ed *EtcdDiscoveryService) setNodeInfo(networkName string,nodeInfo *rpc.NodeInfo) bool{
-	if nodeInfo == nil || nodeInfo.Private == true || nodeInfo.NodeId == ed.localNodeId {
-		return false
-	}
-
-	//筛选关注的服务
-	var discoverServiceSlice = make([]string, 0, 24)
-	for _, pubService := range nodeInfo.PublicServiceList {
-		if cluster.CanDiscoveryService(networkName,pubService) == true {
-			discoverServiceSlice = append(discoverServiceSlice,pubService)
-		}
-	}
-
-	if len(discoverServiceSlice) == 0 {
-		return false
-	}
-
-	var nInfo NodeInfo
-	nInfo.ServiceList = discoverServiceSlice
-	nInfo.PublicServiceList = discoverServiceSlice
-	nInfo.NodeId = nodeInfo.NodeId
-	nInfo.ListenAddr = nodeInfo.ListenAddr
-	nInfo.MaxRpcParamLen = nodeInfo.MaxRpcParamLen
-	nInfo.Retire = nodeInfo.Retire
-	nInfo.Private = nodeInfo.Private
-
-	ed.funSetNode(&nInfo)
-
-	return true
-}
-
-func (ed *EtcdDiscoveryService) close(){
-	for c, ec := range ed.mapClient {
-		if _, err := c.Revoke(context.Background(), ec.leaseID); err != nil {
-			log.Error("etcd Revoke fail",log.ErrorAttr("err",err))
-		}
-		c.Watcher.Close()
-		err := c.Close()
-		if err != nil {
-			log.Error("etcd Close fail",log.ErrorAttr("err",err))
-		}
-	}
-}
-
-func (ed *EtcdDiscoveryService) getServices(client *clientv3.Client,etcdClient *etcdClientInfo,watchKey string) bool {
-	// 根据前缀获取现有的key
-	resp, err := client.Get(context.Background(), watchKey, clientv3.WithPrefix())
-	if err != nil {
-		log.Error("etcd Get fail", log.ErrorAttr("err", err))
-		ed.tryWatch(client, etcdClient)
-		return false
-	}
-
-	// 遍历获取得到的k和v
-	ed.notifyGets(watchKey,resp.Kvs)
-
-	return true
-}
-
-func (ed *EtcdDiscoveryService) watchByClient(client *clientv3.Client,etcdClient *etcdClientInfo){
-	//先关闭所有的watcher
-	for _, watchKey := range etcdClient.watchKeys {
-		// 监视前缀，修改变更server
-		go ed.watcher(client,etcdClient, watchKey)
-	}
-}
-
-// watcher 监听Key的前缀
-func (ed *EtcdDiscoveryService) watcher(client *clientv3.Client,etcdClient *etcdClientInfo,watchKey string) {
-	defer func() {
-		if r := recover(); r != nil {
-			buf := make([]byte, 4096)
-			l := runtime.Stack(buf, false)
-			errString := fmt.Sprint(r)
-			log.Dump(string(buf[:l]),log.String("error",errString))
-
-			ed.tryWatch(client,etcdClient)
-		}
-	}()
-
-	rch := client.Watch(context.Background(), watchKey, clientv3.WithPrefix())
-
-	if ed.getServices(client,etcdClient,watchKey) == false {
-		return
-	}
-
-	for wresp := range rch {
-		for _, ev := range wresp.Events {
-			switch ev.Type {
-			case clientv3.EventTypePut: // 修改或者新增
-				ed.notifyPut(watchKey,ev.Kv)
-			case clientv3.EventTypeDelete: // 删除
-				ed.notifyDelete(watchKey,ev.Kv)
-			}
-		}
-	}
-	
-	ed.tryWatch(client,etcdClient)
-}
-
-func (ed *EtcdDiscoveryService) setNode(netWorkName string,byteNode []byte) string{
-	var nodeInfo rpc.NodeInfo
-	err := proto.Unmarshal(byteNode,&nodeInfo)
-	if err != nil {
-		log.Error("Unmarshal fail",log.String("netWorkName",netWorkName),log.ErrorAttr("err",err))
-		return ""
-	}
-
-	ed.setNodeInfo(netWorkName,&nodeInfo)
-
-	return nodeInfo.NodeId
-}
-
-func (ed *EtcdDiscoveryService) delNode(fullKey string) string{
-	nodeId := ed.getNodeId(fullKey)
-	if nodeId == ed.localNodeId {
-		return ""
-	}
-
-	 ed.funDelNode(nodeId)
-	return nodeId
-}
-
-func (ed *EtcdDiscoveryService) getNetworkNameByWatchKey(watchKey string) string{
-	return watchKey[strings.LastIndex(watchKey,"/")+1:]
-}
-
-func (ed *EtcdDiscoveryService) getNetworkNameByFullKey(fullKey string) string{
-	return fullKey[len(originDir)+1:strings.LastIndex(fullKey,"/")]
-}
-
-func (ed *EtcdDiscoveryService) getNodeId(fullKey string) string{
-	return fullKey[strings.LastIndex(fullKey,"/")+1:]
-}
-
-func (ed *EtcdDiscoveryService) OnEtcdDiscovery(ev event.IEvent){
-	disEvent := ev.(*etcdDiscoveryEvent)
-	switch disEvent.typ {
-	case eeGets:
-		ed.OnEventGets(disEvent.watchKey,disEvent.Kvs)
-	case eePut:
-		if len(disEvent.Kvs) == 1 {
-			ed.OnEventPut(disEvent.watchKey,disEvent.Kvs[0])
-		}
-	case eeDelete:
-		if len(disEvent.Kvs) == 1 {
-			ed.OnEventDelete(disEvent.watchKey,disEvent.Kvs[0])
-		}
-	}
-}
-
-func (ed *EtcdDiscoveryService) notifyGets(watchKey string,Kvs []*mvccpb.KeyValue) {
-	var ev etcdDiscoveryEvent
-	ev.typ = eeGets
-	ev.watchKey = watchKey
-	ev.Kvs = Kvs
-	ed.NotifyEvent(&ev)
-}
-
-func (ed *EtcdDiscoveryService) notifyPut(watchKey string,Kvs *mvccpb.KeyValue) {
-	var ev etcdDiscoveryEvent
-	ev.typ = eePut
-	ev.watchKey = watchKey
-	ev.Kvs = append(ev.Kvs,Kvs)
-	ed.NotifyEvent(&ev)
-}
-
-func (ed *EtcdDiscoveryService) notifyDelete(watchKey string,Kvs *mvccpb.KeyValue) {
-	var ev etcdDiscoveryEvent
-	ev.typ = eeDelete
-	ev.watchKey = watchKey
-	ev.Kvs = append(ev.Kvs,Kvs)
-	ed.NotifyEvent(&ev)
-}
-
-func (ed *EtcdDiscoveryService) OnEventGets(watchKey string,Kvs []*mvccpb.KeyValue) {
-	mapNode := make(map[string]struct{},32)
-	for _, kv := range Kvs {
-		nodeId := ed.setNode(ed.getNetworkNameByFullKey(string(kv.Key)), kv.Value)
-		mapNode[nodeId] = struct{}{}
-		ed.addNodeId(watchKey,nodeId)
-	}
-	
-	// 此段代码为遍历并删除过期节点的逻辑。
-	// 对于mapDiscoveryNodeId中与watchKey关联的所有节点ID，遍历该集合。
-	// 如果某个节点ID不在mapNode中且不是本地节点ID，则调用funDelNode函数删除该节点。
-	mapLastNodeId := ed.mapDiscoveryNodeId[watchKey] // 根据watchKey获取对应的节点ID集合
-	for nodeId := range mapLastNodeId { // 遍历所有节点ID
-	    if _,ok := mapNode[nodeId];ok == false && nodeId != ed.localNodeId { // 检查节点是否不存在于mapNode且不是本地节点
-	        ed.funDelNode(nodeId) // 调用函数删除该节点
-			delete(ed.mapDiscoveryNodeId[watchKey],nodeId)
-	    }
-	}
-}
-
-func (ed *EtcdDiscoveryService) OnEventPut(watchKey string,Kv *mvccpb.KeyValue) {
-	nodeId := ed.setNode(ed.getNetworkNameByFullKey(string(Kv.Key)), Kv.Value)
-	ed.addNodeId(watchKey,nodeId)
-}
-
-func (ed *EtcdDiscoveryService) OnEventDelete(watchKey string,Kv *mvccpb.KeyValue) {
-	nodeId := ed.delNode(string(Kv.Key))
-	delete(ed.mapDiscoveryNodeId[watchKey],nodeId)
-}
-
-func (ed *EtcdDiscoveryService) addNodeId(watchKey string,nodeId string) {
-	if _,ok := ed.mapDiscoveryNodeId[watchKey];ok == false {
-		ed.mapDiscoveryNodeId[watchKey] = make(map[string]struct{})
-	}
-
-	ed.mapDiscoveryNodeId[watchKey][nodeId] = struct{}{}
-}
-
-func (ed *EtcdDiscoveryService) OnNodeDisconnect(nodeId string) {
-	//将Discard结点清理
-	cluster.DiscardNode(nodeId)
-}
-
-func (ed *EtcdDiscoveryService) RPC_ServiceRecord(etcdServiceRecord *service.EtcdServiceRecordEvent,empty *service.Empty) error{
-		var client *clientv3.Client
-
-		//写入到etcd中
-		for c, info := range ed.mapClient{
-			for _,watchKey := range info.watchKeys {
-				if ed.getNetworkNameByWatchKey(watchKey) == etcdServiceRecord.NetworkName {
-					client = c
-					break
-				}
-			}
-		}
-
-		if client == nil {
-			log.Error("etcd record fail,cannot find network name",log.String("networkName",etcdServiceRecord.NetworkName))
-			return errors.New("annot find network name")
-		}
-
-		var lg *clientv3.LeaseGrantResponse
-		var err error
-
-		if etcdServiceRecord.TTLSecond > 0 {
-			ctx,_:=context.WithTimeout(context.Background(),time.Second*3)
-			lg, err = client.Grant(ctx, etcdServiceRecord.TTLSecond)
-			if err != nil {
-				log.Error("etcd record fail,cannot grant lease",log.ErrorAttr("err",err))
-				return errors.New("cannot grant lease")
-			}
-		}
-
-		if lg != nil {
-			ctx,_:=context.WithTimeout(context.Background(),time.Second*3)
-			_, err = client.Put(ctx, path.Join(originDir,etcdServiceRecord.RecordKey),etcdServiceRecord.RecordInfo, clientv3.WithLease(lg.ID))
-			if err != nil {
-				log.Error("etcd record fail,cannot put record",log.ErrorAttr("err",err))
-			}
-			return errors.New("cannot put record")
-		}
-
-		_,err = client.Put(context.Background(), path.Join(originDir,etcdServiceRecord.RecordKey),etcdServiceRecord.RecordInfo)
-		if err != nil {
-			log.Error("etcd record fail,cannot put record",log.ErrorAttr("err",err))
-			return errors.New("cannot put record")
-		}
-
-		return nil
-}

cluster/nodettl.go

@@ -1,71 +0,0 @@
-package cluster
-
-import (
-	"time"
-	"container/list"
-)
-
-type nodeTTL struct {
-	nodeId string
-	refreshTime time.Time
-}
-
-type nodeSetTTL struct {
-	l *list.List
-	mapElement map[string]*list.Element
-	ttl time.Duration
-}
-
-func (ns *nodeSetTTL) init(ttl time.Duration) {
-	ns.ttl = ttl
-	ns.mapElement = make(map[string]*list.Element,32)
-	ns.l = list.New()
-}
-
-func (ns *nodeSetTTL) removeNode(nodeId string) {
-	ele,ok:=ns.mapElement[nodeId]
-	if ok == false {
-		return
-	}
-
-	ns.l.Remove(ele)
-	delete(ns.mapElement,nodeId)
-}
-
-func (ns *nodeSetTTL) addAndRefreshNode(nodeId string){
-	ele,ok:=ns.mapElement[nodeId]
-	if ok == false {
-		ele = ns.l.PushBack(nodeId)
-		ele.Value = &nodeTTL{nodeId,time.Now()}
-		ns.mapElement[nodeId] = ele
-		return
-	}
-
-	ele.Value.(*nodeTTL).refreshTime =  time.Now()
-	ns.l.MoveToBack(ele)
-}
-
-func (ns *nodeSetTTL) checkTTL(cb func(nodeIdList []string)){
-	nodeIdList := []string{}
-	for{
-		f := ns.l.Front()
-		if f == nil {
-			break
-		}
-
-		nt := f.Value.(*nodeTTL)
-		if time.Now().Sub(nt.refreshTime) > ns.ttl {
-			nodeIdList = append(nodeIdList,nt.nodeId)
-		}else{
-			break
-		}
-
-		//删除结点
-		ns.l.Remove(f)
-		delete(ns.mapElement,nt.nodeId)
-	}
-
-	if len(nodeIdList) >0 {
-		cb(nodeIdList)
-	}
-}

cluster/origindiscovery.go

@@ -1,636 +0,0 @@
-package cluster
-
-import (
-	"errors"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/rpc"
-	"github.com/duanhf2012/origin/v2/service"
-	"github.com/duanhf2012/origin/v2/util/timer"
-	"google.golang.org/protobuf/proto"
-	"time"
-)
-
-const OriginDiscoveryMasterName = "DiscoveryMaster"
-const OriginDiscoveryClientName = "DiscoveryClient"
-const RegServiceDiscover = OriginDiscoveryMasterName + ".RPC_RegServiceDiscover"
-const SubServiceDiscover = OriginDiscoveryClientName + ".RPC_SubServiceDiscover"
-const AddSubServiceDiscover = OriginDiscoveryMasterName + ".RPC_AddSubServiceDiscover"
-const NodeRetireRpcMethod = OriginDiscoveryMasterName+".RPC_NodeRetire"
-const RpcPingMethod = OriginDiscoveryMasterName+".RPC_Ping"
-const UnRegServiceDiscover = OriginDiscoveryMasterName+".RPC_UnRegServiceDiscover"
-
-type OriginDiscoveryMaster struct {
-	service.Service
-
-	mapNodeInfo map[string]struct{}
-	nodeInfo    []*rpc.NodeInfo
-
-	nsTTL nodeSetTTL
-}
-
-type OriginDiscoveryClient struct {
-	service.Service
-
-	funDelNode FunDelNode
-	funSetNode FunSetNode
-	localNodeId   string
-
-	mapDiscovery map[string]map[string][]string //map[masterNodeId]map[nodeId]struct{}
-	bRetire bool
-	isRegisterOk bool
-}
-
-var masterService OriginDiscoveryMaster
-var clientService OriginDiscoveryClient
-
-func getOriginDiscovery() IServiceDiscovery {
-	return &clientService
-}
-
-func init() {
-	masterService.SetName(OriginDiscoveryMasterName)
-	clientService.SetName(OriginDiscoveryClientName)
-}
-
-func (ds *OriginDiscoveryMaster) isRegNode(nodeId string) bool {
-	_, ok := ds.mapNodeInfo[nodeId]
-	return ok
-}
-
-func (ds *OriginDiscoveryMaster) updateNodeInfo(nInfo *rpc.NodeInfo) {
-	if _,ok:= ds.mapNodeInfo[nInfo.NodeId];ok == false {
-		return
-	}
-
-	nodeInfo := proto.Clone(nInfo).(*rpc.NodeInfo)
-	for i:=0;i<len(ds.nodeInfo);i++ {
-		if ds.nodeInfo[i].NodeId == nodeInfo.NodeId {
-			ds.nodeInfo[i]  = nodeInfo
-			break
-		}
-	}
-}
-
-func (ds *OriginDiscoveryMaster) addNodeInfo(nInfo *rpc.NodeInfo) {
-	if len(nInfo.PublicServiceList) == 0 {
-		return
-	}
-
-	_, ok := ds.mapNodeInfo[nInfo.NodeId]
-	if ok == true {
-		return
-	}
-	ds.mapNodeInfo[nInfo.NodeId] = struct{}{}
-
-	nodeInfo := proto.Clone(nInfo).(*rpc.NodeInfo)
-	ds.nodeInfo = append(ds.nodeInfo, nodeInfo)
-}
-
-func (ds *OriginDiscoveryMaster) removeNodeInfo(nodeId string) {
-	if _,ok:= ds.mapNodeInfo[nodeId];ok == false {
-		return
-	}
-
-	for i:=0;i<len(ds.nodeInfo);i++ {
-		if ds.nodeInfo[i].NodeId == nodeId {
-			ds.nodeInfo = append(ds.nodeInfo[:i],ds.nodeInfo[i+1:]...)
-			break
-		}
-	}
-
-	ds.nsTTL.removeNode(nodeId)
-	delete(ds.mapNodeInfo,nodeId)
-}
-
-func (ds *OriginDiscoveryMaster) OnInit() error {
-	ds.mapNodeInfo = make(map[string]struct{}, 20)
-	ds.RegNodeConnListener(ds)
-	ds.RegNatsConnListener(ds)
-
-	ds.nsTTL.init(time.Duration(cluster.GetOriginDiscovery().TTLSecond)*time.Second)
-
-	return nil
-}
-
-func (ds *OriginDiscoveryMaster) checkTTL(){
-	if cluster.IsNatsMode() == false {
-		return
-	}
-
-	interval := time.Duration(cluster.GetOriginDiscovery().TTLSecond)*time.Second
-	interval = interval /3 /2
-	if interval < time.Second {
-		interval = time.Second
-	}
-
-	ds.NewTicker(interval,func(t *timer.Ticker){
-		ds.nsTTL.checkTTL(func(nodeIdList []string) {
-			for _,nodeId := range nodeIdList {
-				log.Info("TTL expiry",log.String("nodeId",nodeId))
-				ds.OnNodeDisconnect(nodeId)
-			}
-		})
-	})
-}
-
-func (ds *OriginDiscoveryMaster) OnStart() {
-	var nodeInfo rpc.NodeInfo
-	localNodeInfo := cluster.GetLocalNodeInfo()
-	nodeInfo.NodeId = localNodeInfo.NodeId
-	nodeInfo.ListenAddr = localNodeInfo.ListenAddr
-	nodeInfo.PublicServiceList = localNodeInfo.PublicServiceList
-	nodeInfo.MaxRpcParamLen = localNodeInfo.MaxRpcParamLen
-	nodeInfo.Private = localNodeInfo.Private
-	nodeInfo.Retire = localNodeInfo.Retire
-	ds.addNodeInfo(&nodeInfo)
-
-	ds.checkTTL()
-}
-
-func (dc *OriginDiscoveryMaster) OnNatsConnected(){
-	//向所有的节点同步服务发现信息
-	var notifyDiscover rpc.SubscribeDiscoverNotify
-	notifyDiscover.IsFull = true
-	notifyDiscover.NodeInfo = dc.nodeInfo
-	notifyDiscover.MasterNodeId = cluster.GetLocalNodeInfo().NodeId
-	dc.RpcCastGo(SubServiceDiscover, &notifyDiscover)
-}
-
-func (dc *OriginDiscoveryMaster)  OnNatsDisconnect(){
-}
-
-func (ds *OriginDiscoveryMaster) OnNodeConnected(nodeId string) {
-}
-
-func (ds *OriginDiscoveryMaster) OnNodeDisconnect(nodeId string) {
-	if ds.isRegNode(nodeId) == false {
-		return
-	}
-
-	ds.removeNodeInfo(nodeId)
-
-	//主动删除已经存在的结点,确保先断开，再连接
-	var notifyDiscover rpc.SubscribeDiscoverNotify
-	notifyDiscover.MasterNodeId = cluster.GetLocalNodeInfo().NodeId
-	notifyDiscover.DelNodeId = nodeId
-
-	//删除结点
-	cluster.DelNode(nodeId)
-
-	//无注册过的结点不广播，避免非当前Master网络中的连接断开时通知到本网络
-	ds.CastGo(SubServiceDiscover, &notifyDiscover)
-}
-
-func (ds *OriginDiscoveryMaster) RpcCastGo(serviceMethod string, args interface{}) {
-	for nodeId, _ := range ds.mapNodeInfo {
-		ds.GoNode(nodeId, serviceMethod, args)
-	}
-}
-
-func (ds *OriginDiscoveryMaster) RPC_Ping(req *rpc.Ping, res *rpc.Pong) error {
-	if ds.isRegNode(req.NodeId) == false{
-		res.Ok = false
-		return nil
-	}
-
-	res.Ok = true
-	ds.nsTTL.addAndRefreshNode(req.NodeId)
-	return nil
-}
-
-func (ds *OriginDiscoveryMaster) RPC_NodeRetire(req *rpc.NodeRetireReq, res *rpc.Empty) error {
-	log.Info("node is retire",log.String("nodeId",req.NodeInfo.NodeId),log.Bool("retire",req.NodeInfo.Retire))
-
-	ds.updateNodeInfo(req.NodeInfo)
-
-	var notifyDiscover rpc.SubscribeDiscoverNotify
-	notifyDiscover.MasterNodeId = cluster.GetLocalNodeInfo().NodeId
-	notifyDiscover.NodeInfo = append(notifyDiscover.NodeInfo, req.NodeInfo)
-	ds.RpcCastGo(SubServiceDiscover, &notifyDiscover)
-
-	return nil
-}
-
-// 收到注册过来的结点
-func (ds *OriginDiscoveryMaster) RPC_RegServiceDiscover(req *rpc.RegServiceDiscoverReq, res *rpc.SubscribeDiscoverNotify) error {
-	if req.NodeInfo == nil {
-		err := errors.New("RPC_RegServiceDiscover req is error.")
-		log.Error(err.Error())
-
-		return err
-	}
-
-	if req.NodeInfo.NodeId != cluster.GetLocalNodeInfo().NodeId {
-		ds.nsTTL.addAndRefreshNode(req.NodeInfo.NodeId)
-	}
-
-	//广播给其他所有结点
-	var notifyDiscover rpc.SubscribeDiscoverNotify
-	notifyDiscover.MasterNodeId = cluster.GetLocalNodeInfo().NodeId
-	notifyDiscover.NodeInfo = append(notifyDiscover.NodeInfo, req.NodeInfo)
-	ds.RpcCastGo(SubServiceDiscover, &notifyDiscover)
-
-	//存入本地
-	ds.addNodeInfo(req.NodeInfo)
-
-	//初始化结点信息
-	var nodeInfo NodeInfo
-	nodeInfo.NodeId = req.NodeInfo.NodeId
-	nodeInfo.Private = req.NodeInfo.Private
-	nodeInfo.ServiceList = req.NodeInfo.PublicServiceList
-	nodeInfo.PublicServiceList = req.NodeInfo.PublicServiceList
-	nodeInfo.ListenAddr = req.NodeInfo.ListenAddr
-	nodeInfo.MaxRpcParamLen = req.NodeInfo.MaxRpcParamLen
-	nodeInfo.Retire = req.NodeInfo.Retire
-
-	//主动删除已经存在的结点,确保先断开，再连接
-	cluster.serviceDiscoveryDelNode(nodeInfo.NodeId)
-
-	//加入到本地Cluster模块中，将连接该结点
-	cluster.serviceDiscoverySetNodeInfo(&nodeInfo)
-
-
-	res.IsFull = true
-	res.NodeInfo = ds.nodeInfo
-	res.MasterNodeId = cluster.GetLocalNodeInfo().NodeId
-	return nil
-}
-
-func (ds *OriginDiscoveryMaster) RPC_UnRegServiceDiscover(req *rpc.UnRegServiceDiscoverReq, res *rpc.Empty) error {
-	log.Debug("RPC_UnRegServiceDiscover",log.String("nodeId",req.NodeId))
-	ds.OnNodeDisconnect(req.NodeId)
-	return nil
-}
-
-func (dc *OriginDiscoveryClient) OnInit() error {
-	dc.RegNodeConnListener(dc)
-	dc.RegNatsConnListener(dc)
-
-	dc.mapDiscovery = map[string]map[string][]string{}
-	//dc.mapMasterNetwork = map[string]string{}
-
-	return nil
-}
-
-func (dc *OriginDiscoveryClient) addMasterNode(masterNodeId string, nodeId string,serviceList []string) {
-	_, ok := dc.mapDiscovery[masterNodeId]
-	if ok == false {
-		dc.mapDiscovery[masterNodeId] = map[string][]string{}
-	}
-	dc.mapDiscovery[masterNodeId][nodeId] = serviceList
-}
-
-func (dc *OriginDiscoveryClient) getNodePublicService(masterNodeId string,nodeId string) []string{
-	mapNodeId, ok := dc.mapDiscovery[masterNodeId]
-	if ok == false {
-		return nil
-	}
-
-	publicService := mapNodeId[nodeId]
-	return publicService
-}
-
-func (dc *OriginDiscoveryClient) removeMasterNode(masterNodeId string, nodeId string) {
-	mapNodeId, ok := dc.mapDiscovery[masterNodeId]
-	if ok == false {
-		return
-	}
-
-	delete(mapNodeId, nodeId)
-}
-
-func (dc *OriginDiscoveryClient) findNodeId(nodeId string) bool {
-	for _, mapNodeId := range dc.mapDiscovery {
-		_, ok := mapNodeId[nodeId]
-		if ok == true {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (dc *OriginDiscoveryClient) ping(){
-	interval := time.Duration(cluster.GetOriginDiscovery().TTLSecond)*time.Second
-	interval = interval /3
-	if interval < time.Second {
-		interval = time.Second
-	}
-
-	dc.NewTicker(interval,func(t *timer.Ticker){
-		if cluster.IsNatsMode() == false || dc.isRegisterOk == false{
-			return
-		}
-		var ping rpc.Ping
-		ping.NodeId = cluster.GetLocalNodeInfo().NodeId
-		masterNodes := GetCluster().GetOriginDiscovery().MasterNodeList
-		for i:=0;i<len(masterNodes);i++ {
-			if masterNodes[i].NodeId == cluster.GetLocalNodeInfo().NodeId {
-				continue
-			}
-
-			masterNodeId := masterNodes[i].NodeId
-			dc.AsyncCallNodeWithTimeout(3*time.Second,masterNodeId,RpcPingMethod,&ping, func(empty *rpc.Pong,err error) {
-				if err == nil && empty.Ok == false{
-					//断开master重
-					dc.regServiceDiscover(masterNodeId)
-				}
-			})
-		}
-	})
-}
-
-
-func (dc *OriginDiscoveryClient) OnStart() {
-	//2.添加并连接发现主结点
-	dc.addDiscoveryMaster()
-	dc.ping()
-}
-
-func (dc *OriginDiscoveryClient) addDiscoveryMaster() {
-	discoveryNodeList := cluster.GetOriginDiscovery()
-
-	for i := 0; i < len(discoveryNodeList.MasterNodeList); i++ {
-		if discoveryNodeList.MasterNodeList[i].NodeId == cluster.GetLocalNodeInfo().NodeId {
-			continue
-		}
-		dc.funSetNode(&discoveryNodeList.MasterNodeList[i])
-	}
-}
-
-func (dc *OriginDiscoveryClient) fullCompareDiffNode(masterNodeId string, mapNodeInfo map[string]*rpc.NodeInfo) []string {
-	if mapNodeInfo == nil {
-		return nil
-	}
-
-	diffNodeIdSlice := make([]string, 0, len(mapNodeInfo))
-	mapNodeId := map[string][]string{}
-	mapNodeId, ok := dc.mapDiscovery[masterNodeId]
-	if ok == false {
-		return nil
-	}
-
-	//本地任何Master都不存在的，放到diffNodeIdSlice
-	for nodeId, _ := range mapNodeId {
-		_, ok := mapNodeInfo[nodeId]
-		if ok == false {
-			diffNodeIdSlice = append(diffNodeIdSlice, nodeId)
-		}
-	}
-
-	return diffNodeIdSlice
-}
-
-//订阅发现的服务通知
-func (dc *OriginDiscoveryClient) RPC_SubServiceDiscover(req *rpc.SubscribeDiscoverNotify) error {
-	mapNodeInfo := map[string]*rpc.NodeInfo{}
-	for _, nodeInfo := range req.NodeInfo {
-		//不对本地结点或者不存在任何公开服务的结点
-		if nodeInfo.NodeId == dc.localNodeId {
-			continue
-		}
-
-		if cluster.IsOriginMasterDiscoveryNode(cluster.GetLocalNodeInfo().NodeId) == false && len(nodeInfo.PublicServiceList) == 1 &&
-			nodeInfo.PublicServiceList[0] == OriginDiscoveryClientName {
-			continue
-		}
-
-		//遍历所有的公开服务，并筛选之
-		for _, serviceName := range nodeInfo.PublicServiceList {
-			nInfo := mapNodeInfo[nodeInfo.NodeId]
-			if nInfo == nil {
-				nInfo = &rpc.NodeInfo{}
-				nInfo.NodeId = nodeInfo.NodeId
-				nInfo.ListenAddr = nodeInfo.ListenAddr
-				nInfo.MaxRpcParamLen = nodeInfo.MaxRpcParamLen
-				nInfo.Retire = nodeInfo.Retire
-				nInfo.Private = nodeInfo.Private
-
-				mapNodeInfo[nodeInfo.NodeId] = nInfo
-			}
-
-			nInfo.PublicServiceList = append(nInfo.PublicServiceList, serviceName)
-		}
-	}
-
-	//如果为完整同步，则找出差异的结点
-	var willDelNodeId []string
-	if req.IsFull == true {
-		diffNode := dc.fullCompareDiffNode(req.MasterNodeId, mapNodeInfo)
-		if len(diffNode) > 0 {
-			willDelNodeId = append(willDelNodeId, diffNode...)
-		}
-	}
-
-	//指定删除结点
-	if req.DelNodeId != rpc.NodeIdNull && req.DelNodeId != dc.localNodeId {
-		willDelNodeId = append(willDelNodeId, req.DelNodeId)
-	}
-
-	//删除不必要的结点
-	for _, nodeId := range willDelNodeId {
-		dc.funDelNode(nodeId)
-		dc.removeMasterNode(req.MasterNodeId, nodeId)
-	}
-
-	//设置新结点
-	for _, nodeInfo := range mapNodeInfo {
-		dc.addMasterNode(req.MasterNodeId, nodeInfo.NodeId,nodeInfo.PublicServiceList)
-		bSet := dc.setNodeInfo(req.MasterNodeId,nodeInfo)
-		if bSet == false {
-			continue
-		}
-	}
-
-	return nil
-}
-
-func (dc *OriginDiscoveryClient) OnNodeConnected(nodeId string) {
-	dc.regServiceDiscover(nodeId)
-}
-
-func (dc *OriginDiscoveryClient) OnRelease(){
-	log.Debug("OriginDiscoveryClient")
-
-	//取消注册
-	var nodeRetireReq rpc.UnRegServiceDiscoverReq
-	nodeRetireReq.NodeId = cluster.GetLocalNodeInfo().NodeId
-
-	masterNodeList := cluster.GetOriginDiscovery()
-	for i:=0;i<len(masterNodeList.MasterNodeList);i++{
-		if masterNodeList.MasterNodeList[i].NodeId == cluster.GetLocalNodeInfo().NodeId {
-			continue
-		}
-
-		err := dc.CallNodeWithTimeout(3*time.Second,masterNodeList.MasterNodeList[i].NodeId,UnRegServiceDiscover,&nodeRetireReq,&rpc.Empty{})
-		if err!= nil {
-			log.Error("call "+UnRegServiceDiscover+" is fail",log.ErrorAttr("err",err))
-		}
-	}
-}
-
-func (dc *OriginDiscoveryClient) OnRetire(){
-	dc.bRetire = true
-
-	masterNodeList := cluster.GetOriginDiscovery()
-	for i:=0;i<len(masterNodeList.MasterNodeList);i++{
-		var nodeRetireReq rpc.NodeRetireReq
-
-		nodeRetireReq.NodeInfo = &rpc.NodeInfo{}
-		nodeRetireReq.NodeInfo.NodeId = cluster.localNodeInfo.NodeId
-		nodeRetireReq.NodeInfo.ListenAddr = cluster.localNodeInfo.ListenAddr
-		nodeRetireReq.NodeInfo.MaxRpcParamLen = cluster.localNodeInfo.MaxRpcParamLen
-		nodeRetireReq.NodeInfo.PublicServiceList =  cluster.localNodeInfo.PublicServiceList
-		nodeRetireReq.NodeInfo.Retire = dc.bRetire
-		nodeRetireReq.NodeInfo.Private = cluster.localNodeInfo.Private
-
-		err := dc.GoNode(masterNodeList.MasterNodeList[i].NodeId,NodeRetireRpcMethod,&nodeRetireReq)
-		if err!= nil {
-			log.Error("call "+NodeRetireRpcMethod+" is fail",log.ErrorAttr("err",err))
-		}
-	}
-}
-
-func (dc *OriginDiscoveryClient) tryRegServiceDiscover(nodeId string){
-	dc.AfterFunc(time.Second*3, func(timer *timer.Timer) {
-		dc.regServiceDiscover(nodeId)
-	})
-}
-
-func (dc *OriginDiscoveryClient) regServiceDiscover(nodeId string){
-	if nodeId == cluster.GetLocalNodeInfo().NodeId {
-		return
-	}
-	nodeInfo := cluster.getOriginMasterDiscoveryNodeInfo(nodeId)
-	if nodeInfo == nil {
-		return
-	}
-
-	var req rpc.RegServiceDiscoverReq
-	req.NodeInfo = &rpc.NodeInfo{}
-	req.NodeInfo.NodeId = cluster.localNodeInfo.NodeId
-	req.NodeInfo.ListenAddr = cluster.localNodeInfo.ListenAddr
-	req.NodeInfo.MaxRpcParamLen = cluster.localNodeInfo.MaxRpcParamLen
-	req.NodeInfo.PublicServiceList =  cluster.localNodeInfo.PublicServiceList
-	req.NodeInfo.Retire = dc.bRetire
-	req.NodeInfo.Private = cluster.localNodeInfo.Private
-	log.Debug("regServiceDiscover",log.String("nodeId",nodeId))
-	//向Master服务同步本Node服务信息
-	_,err := dc.AsyncCallNodeWithTimeout(3*time.Second,nodeId, RegServiceDiscover, &req, func(res *rpc.SubscribeDiscoverNotify, err error) {
-		if err != nil {
-			log.Error("call "+RegServiceDiscover+" is fail :"+ err.Error())
-			dc.tryRegServiceDiscover(nodeId)
-			return
-		}
-
-		dc.isRegisterOk = true
-		dc.RPC_SubServiceDiscover(res)
-	})
-
-	if err != nil {
-		log.Error("call "+ RegServiceDiscover+" is fail :"+ err.Error())
-		dc.tryRegServiceDiscover(nodeId)
-	}
-}
-
-func (dc *OriginDiscoveryClient) setNodeInfo(masterNodeId string,nodeInfo *rpc.NodeInfo) bool{
-	if nodeInfo == nil || nodeInfo.Private == true || nodeInfo.NodeId == dc.localNodeId {
-		return false
-	}
-
-	//筛选关注的服务
-	var discoverServiceSlice = make([]string, 0, 24)
-	for _, pubService := range nodeInfo.PublicServiceList {
-		if cluster.CanDiscoveryService(masterNodeId,pubService) == true {
-			discoverServiceSlice = append(discoverServiceSlice,pubService)
-		}
-	}
-
-	if len(discoverServiceSlice) == 0 {
-		return false
-	}
-
-	var nInfo NodeInfo
-	nInfo.ServiceList = discoverServiceSlice
-	nInfo.PublicServiceList = discoverServiceSlice
-	nInfo.NodeId = nodeInfo.NodeId
-	nInfo.ListenAddr = nodeInfo.ListenAddr
-	nInfo.MaxRpcParamLen = nodeInfo.MaxRpcParamLen
-	nInfo.Retire = nodeInfo.Retire
-	nInfo.Private = nodeInfo.Private
-
-	dc.funSetNode(&nInfo)
-
-	return true
-}
-
-func (dc *OriginDiscoveryClient) OnNodeDisconnect(nodeId string) {
-	//将Discard结点清理
-	cluster.DiscardNode(nodeId)
-}
-
-func (dc *OriginDiscoveryClient) InitDiscovery(localNodeId string, funDelNode FunDelNode, funSetNode FunSetNode) error {
-	dc.localNodeId = localNodeId
-	dc.funDelNode = funDelNode
-	dc.funSetNode = funSetNode
-
-	return nil
-}
-
-func (cls *Cluster) checkOriginDiscovery(localNodeId string) (bool, bool) {
-	var localMaster bool //本结点是否为Master结点
-	var hasMaster bool   //是否配置Master服务
-
-	//遍历所有结点
-	for _, nodeInfo := range cls.discoveryInfo.Origin.MasterNodeList {
-		if nodeInfo.NodeId == localNodeId {
-			localMaster = true
-		}
-		hasMaster = true
-	}
-
-	//返回查询结果
-	return localMaster, hasMaster
-}
-
-func (cls *Cluster) AddDiscoveryService(serviceName string, bPublicService bool) {
-	addServiceList := append([]string{},serviceName)
-	cls.localNodeInfo.ServiceList = append(addServiceList,cls.localNodeInfo.ServiceList...)
-	if bPublicService {
-		cls.localNodeInfo.PublicServiceList = append(cls.localNodeInfo.PublicServiceList, serviceName)
-	}
-
-	if _, ok := cls.mapServiceNode[serviceName]; ok == false {
-		cls.mapServiceNode[serviceName] = map[string]struct{}{}
-	}
-	cls.mapServiceNode[serviceName][cls.localNodeInfo.NodeId] = struct{}{}
-}
-
-
-func (cls *Cluster) IsOriginMasterDiscoveryNode(nodeId string) bool {
-	return cls.getOriginMasterDiscoveryNodeInfo(nodeId) != nil
-}
-
-func (cls *Cluster) getOriginMasterDiscoveryNodeInfo(nodeId string) *NodeInfo {
-	if cls.discoveryInfo.Origin == nil {
-		return nil
-	}
-
-	for i := 0; i < len(cls.discoveryInfo.Origin.MasterNodeList); i++ {
-		if cls.discoveryInfo.Origin.MasterNodeList[i].NodeId == nodeId {
-			return &cls.discoveryInfo.Origin.MasterNodeList[i]
-		}
-	}
-
-	return nil
-}
-
-func (dc *OriginDiscoveryClient) OnNatsConnected(){
-	masterNodes := GetCluster().GetOriginDiscovery().MasterNodeList
-	for i:=0;i<len(masterNodes);i++ {
-		dc.regServiceDiscover(masterNodes[i].NodeId)
-	}
-}
-
-func (dc *OriginDiscoveryClient)  OnNatsDisconnect(){
-}

cluster/parsecfg.go

@@ -2,159 +2,21 @@ package cluster
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/rpc"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/rpc"
 	jsoniter "github.com/json-iterator/go"
 	"os"
 	"path/filepath"
 	"strings"
-	"time"
-	"errors"
 )
 
 var json = jsoniter.ConfigCompatibleWithStandardLibrary
 
-type EtcdList struct {
-	NetworkName []string
-	Endpoints []string
-}
-
-type EtcdDiscovery struct {
-	DialTimeoutMillisecond time.Duration
-	TTLSecond int64
-
-	EtcdList []EtcdList
-}
-
-type OriginDiscovery struct {
-	TTLSecond int64
-	MasterNodeList []NodeInfo
-}
-
-type DiscoveryType int
-
-const (
-	InvalidType = 0
-	OriginType = 1
-	EtcdType = 2
-)
-
-const MinTTL = 3
-
-type DiscoveryInfo struct {
-	discoveryType DiscoveryType
-	Etcd          *EtcdDiscovery  //etcd
-	Origin        *OriginDiscovery      //orign
-}
-
-type NatsConfig struct {
-	NatsUrl string
-	NoRandomize bool
-}
-
-type RpcMode struct {
-	Typ string `json:"Type"`
-	Nats  NatsConfig
-
-}
-
 type NodeInfoList struct {
-	RpcMode             RpcMode
-	Discovery 			DiscoveryInfo
+	MasterDiscoveryNode []NodeInfo //用于服务发现Node
 	NodeList            []NodeInfo
 }
 
-func (d *DiscoveryInfo) getDiscoveryType() DiscoveryType{
-	return d.discoveryType
-}
-
-func (d *DiscoveryInfo) setDiscovery(discoveryInfo *DiscoveryInfo) error{
-	var err error
-	err = d.setOrigin(discoveryInfo.Origin)
-	if err != nil {
-		return err
-	}
-
-	err = d.setEtcd(discoveryInfo.Etcd)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (d *DiscoveryInfo) setEtcd(etcd *EtcdDiscovery) error{
-	if etcd == nil {
-		return nil
-	}
-
-	if  d.discoveryType != InvalidType {
-		return fmt.Errorf("Repeat configuration of Discovery")
-	}
-
-	//Endpoints不允许重复
-	mapAddr:=make (map[string]struct{})
-	for _, n := range etcd.EtcdList {
-		for _,endPoint := range n.Endpoints {
-			if _,ok:=mapAddr[endPoint];ok == true {
-				return fmt.Errorf("etcd discovery config Etcd.EtcdList.Endpoints %+v is repeat",endPoint)
-			}
-			mapAddr[endPoint] = struct{}{}
-		}
-
-		//networkName不允许重复
-		mapNetworkName := make(map[string]struct{})
-		for _,netName := range n.NetworkName{
-			if _,ok := mapNetworkName[netName];ok == true {
-				return fmt.Errorf("etcd discovery config Etcd.EtcdList.NetworkName %+v is repeat",n.NetworkName)
-			}
-
-			mapNetworkName[netName] = struct{}{}
-		}
-	}
-
-	if etcd.TTLSecond < MinTTL {
-		etcd.TTLSecond = MinTTL
-	}
-	etcd.DialTimeoutMillisecond = etcd.DialTimeoutMillisecond * time.Millisecond
-
-	d.Etcd = etcd
-	d.discoveryType = EtcdType
-
-	return nil
-}
-
-func (d *DiscoveryInfo) setOrigin(originDiscovery *OriginDiscovery) error{
-	if originDiscovery== nil || len(originDiscovery.MasterNodeList)==0 {
-		return nil
-	}
-
-	if d.discoveryType != InvalidType {
-		return fmt.Errorf("Repeat configuration of Discovery")
-	}
-
-	mapListenAddr := make(map[string]struct{})
-	mapNodeId := make(map[string]struct{})
-	for _, n := range originDiscovery.MasterNodeList {
-		if _, ok := mapListenAddr[n.ListenAddr]; ok == true {
-			return fmt.Errorf("discovery config Origin.ListenAddr %s is repeat", n.ListenAddr)
-		}
-		mapListenAddr[n.ListenAddr] = struct{}{}
-
-		if _, ok := mapNodeId[n.NodeId]; ok == true {
-			return fmt.Errorf("discovery config Origin.NodeId %s is repeat", n.NodeId)
-		}
-		mapNodeId[n.NodeId] = struct{}{}
-	}
-
-	d.Origin = originDiscovery
-	if d.Origin.TTLSecond < MinTTL {
-		d.Origin.TTLSecond = MinTTL
-	}
-	d.discoveryType = OriginType
-	return nil
-}
-
 func (cls *Cluster) ReadClusterConfig(filepath string) (*NodeInfoList, error) {
 	c := &NodeInfoList{}
 	d, err := os.ReadFile(filepath)
@@ -169,7 +31,7 @@ func (cls *Cluster) ReadClusterConfig(filepath string) (*NodeInfoList, error) {
 	return c, nil
 }
 
-func (cls *Cluster) readServiceConfig(filepath string) (interface{}, map[string]interface{}, map[string]map[string]interface{}, error) {
+func (cls *Cluster) readServiceConfig(filepath string) (interface{}, map[string]interface{}, map[int]map[string]interface{}, error) {
 	c := map[string]interface{}{}
 	//读取配置
 	d, err := os.ReadFile(filepath)
@@ -188,7 +50,7 @@ func (cls *Cluster) readServiceConfig(filepath string) (interface{}, map[string]
 		serviceConfig = serviceCfg.(map[string]interface{})
 	}
 
-	mapNodeService := map[string]map[string]interface{}{}
+	mapNodeService := map[int]map[string]interface{}{}
 	nodeServiceCfg, ok := c["NodeService"]
 	if ok == true {
 		nodeServiceList := nodeServiceCfg.([]interface{})
@@ -198,79 +60,40 @@ func (cls *Cluster) readServiceConfig(filepath string) (interface{}, map[string]
 			if ok == false {
 				log.Fatal("NodeService list not find nodeId field")
 			}
-			mapNodeService[nodeId.(string)] = serviceCfg
+			mapNodeService[int(nodeId.(float64))] = serviceCfg
 		}
 	}
 	return GlobalCfg, serviceConfig, mapNodeService, nil
 }
 
-func (cls *Cluster) SetRpcMode(cfgRpcMode *RpcMode,rpcMode *RpcMode) error {
-	//忽略掉没有设置的配置
-	if cfgRpcMode.Typ == "" {
-		return nil
-	}
-
-	//不允许重复的配置Rpc模式
-
-	if cfgRpcMode.Typ != "" && rpcMode.Typ != ""{
-		return errors.New("repeat config RpcMode")
-	}
-
-	//检查Typ是否合法
-	if cfgRpcMode.Typ!="Nats" && cfgRpcMode.Typ!="Default" {
-		return fmt.Errorf("RpcMode %s is not support", rpcMode.Typ)
-	}
-
-	if cfgRpcMode.Typ == "Nats" && len(cfgRpcMode.Nats.NatsUrl)==0 {
-		return fmt.Errorf("nats rpc mode config NatsUrl is empty")
-	}
-
-	*rpcMode = *cfgRpcMode
-
-	return nil
-}
-
-func (cls *Cluster) readLocalClusterConfig(nodeId string) (DiscoveryInfo, []NodeInfo,RpcMode, error) {
+func (cls *Cluster) readLocalClusterConfig(nodeId int) ([]NodeInfo, []NodeInfo, error) {
 	var nodeInfoList []NodeInfo
-	var discoveryInfo DiscoveryInfo
-	var rpcMode RpcMode
-
+	var masterDiscoverNodeList []NodeInfo
 	clusterCfgPath := strings.TrimRight(configDir, "/") + "/cluster"
 	fileInfoList, err := os.ReadDir(clusterCfgPath)
 	if err != nil {
-		return discoveryInfo, nil,rpcMode, fmt.Errorf("Read dir %s is fail :%+v", clusterCfgPath, err)
+		return nil, nil, fmt.Errorf("Read dir %s is fail :%+v", clusterCfgPath, err)
 	}
 
 	//读取任何文件,只读符合格式的配置,目录下的文件可以自定义分文件
 	for _, f := range fileInfoList {
 		if f.IsDir() == false {
 			filePath := strings.TrimRight(strings.TrimRight(clusterCfgPath, "/"), "\\") + "/" + f.Name()
-			fileNodeInfoList, rerr := cls.ReadClusterConfig(filePath)
-
-			if rerr != nil {
-				return discoveryInfo, nil,rpcMode, fmt.Errorf("read file path %s is error:%+v", filePath, rerr)
-			}
-
-			err = cls.SetRpcMode(&fileNodeInfoList.RpcMode,&rpcMode)
+			localNodeInfoList, err := cls.ReadClusterConfig(filePath)
 			if err != nil {
-				return discoveryInfo, nil,rpcMode, err
+				return nil, nil, fmt.Errorf("read file path %s is error:%+v", filePath, err)
 			}
-
-			err = discoveryInfo.setDiscovery(&fileNodeInfoList.Discovery)
-			if err != nil {
-				return  discoveryInfo,nil,rpcMode,err
-			}
-
-			for _, nodeInfo := range fileNodeInfoList.NodeList {
-				if nodeInfo.NodeId == nodeId || nodeId == rpc.NodeIdNull {
+			masterDiscoverNodeList = append(masterDiscoverNodeList, localNodeInfoList.MasterDiscoveryNode...)
+			for _, nodeInfo := range localNodeInfoList.NodeList {
+				if nodeInfo.NodeId == nodeId || nodeId == 0 {
 					nodeInfoList = append(nodeInfoList, nodeInfo)
 				}
 			}
 		}
 	}
 
-	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)
+	if nodeId != 0 && (len(nodeInfoList) != 1) {
+		return nil, nil, fmt.Errorf("%d configurations were found for the configuration with node ID %d!", len(nodeInfoList), nodeId)
 	}
 
 	for i, _ := range nodeInfoList {
@@ -284,10 +107,10 @@ func (cls *Cluster) readLocalClusterConfig(nodeId string) (DiscoveryInfo, []Node
 		}
 	}
 
-	return discoveryInfo, nodeInfoList, rpcMode,nil
+	return masterDiscoverNodeList, nodeInfoList, nil
 }
 
-func (cls *Cluster) readLocalService(localNodeId string) error {
+func (cls *Cluster) readLocalService(localNodeId int) error {
 	clusterCfgPath := strings.TrimRight(configDir, "/") + "/cluster"
 	fileInfoList, err := os.ReadDir(clusterCfgPath)
 	if err != nil {
@@ -378,40 +201,47 @@ func (cls *Cluster) readLocalService(localNodeId string) error {
 func (cls *Cluster) parseLocalCfg() {
 	rpcInfo := NodeRpcInfo{}
 	rpcInfo.nodeInfo = cls.localNodeInfo
-	rpcInfo.client = rpc.NewLClient(rpcInfo.nodeInfo.NodeId,&cls.callSet)
+	rpcInfo.client = rpc.NewLClient(rpcInfo.nodeInfo.NodeId)
 
 	cls.mapRpc[cls.localNodeInfo.NodeId] = &rpcInfo
 
 	for _, sName := range cls.localNodeInfo.ServiceList {
 		if _, ok := cls.mapServiceNode[sName]; ok == false {
-			cls.mapServiceNode[sName] = make(map[string]struct{})
+			cls.mapServiceNode[sName] = make(map[int]struct{})
 		}
 
 		cls.mapServiceNode[sName][cls.localNodeInfo.NodeId] = struct{}{}
 	}
 }
 
-func (cls *Cluster) IsNatsMode() bool {
-	return cls.rpcMode.Typ == "Nats"
+func (cls *Cluster) checkDiscoveryNodeList(discoverMasterNode []NodeInfo) bool {
+	for i := 0; i < len(discoverMasterNode)-1; i++ {
+		for j := i + 1; j < len(discoverMasterNode); j++ {
+			if discoverMasterNode[i].NodeId == discoverMasterNode[j].NodeId ||
+				discoverMasterNode[i].ListenAddr == discoverMasterNode[j].ListenAddr {
+				return false
+			}
+		}
+	}
+
+	return true
 }
 
-func (cls *Cluster) GetNatsUrl() string {
-	return cls.rpcMode.Nats.NatsUrl
-}
-
-func (cls *Cluster) InitCfg(localNodeId string) error {
+func (cls *Cluster) InitCfg(localNodeId int) error {
 	cls.localServiceCfg = map[string]interface{}{}
-	cls.mapRpc = map[string]*NodeRpcInfo{}
-	cls.mapServiceNode = map[string]map[string]struct{}{}
+	cls.mapRpc = map[int]*NodeRpcInfo{}
+	cls.mapServiceNode = map[string]map[int]struct{}{}
 
 	//加载本地结点的NodeList配置
-	discoveryInfo, nodeInfoList,rpcMode, err := cls.readLocalClusterConfig(localNodeId)
+	discoveryNode, nodeInfoList, err := cls.readLocalClusterConfig(localNodeId)
 	if err != nil {
 		return err
 	}
 	cls.localNodeInfo = nodeInfoList[0]
-	cls.discoveryInfo = discoveryInfo
-	cls.rpcMode = rpcMode
+	if cls.checkDiscoveryNodeList(discoveryNode) == false {
+		return fmt.Errorf("DiscoveryNode config is error!")
+	}
+	cls.masterDiscoveryNodeList = discoveryNode
 
 	//读取本地服务配置
 	err = cls.readLocalService(localNodeId)

cluster/servicediscovery.go

@@ -1,12 +1,12 @@
 package cluster
 
-
 type OperType int
 
-type FunDelNode func (nodeId string)
-type FunSetNode func(nodeInfo *NodeInfo)
+type FunDelNode func (nodeId int,immediately bool)
+type FunSetNodeInfo func(nodeInfo *NodeInfo)
 
 type IServiceDiscovery interface {
-	InitDiscovery(localNodeId string,funDelNode FunDelNode,funSetNodeInfo FunSetNode) error
+	InitDiscovery(localNodeId int,funDelNode FunDelNode,funSetNodeInfo FunSetNodeInfo) error
+	OnNodeStop()
 }
 

concurrent/concurrent.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"runtime"
 
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"sync/atomic"
 )
 

concurrent/dispatch.go

@@ -8,8 +8,8 @@ import (
 	"fmt"
 	"runtime"
 
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/util/queue"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/util/queue"
 )
 
 var idleTimeout = int64(2 * time.Second)

concurrent/worker.go

@@ -7,7 +7,7 @@ import (
 	"fmt"
 	"runtime"
 
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 )
 
 type task struct {

event/event.go

@@ -2,7 +2,7 @@ package event
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"runtime"
 	"sync"
 )

event/eventpool.go

@@ -1,6 +1,6 @@
 package event
 
-import "github.com/duanhf2012/origin/v2/util/sync"
+import "github.com/duanhf2012/origin/util/sync"
 
 // eventPool的内存池,缓存Event
 const defaultMaxEventChannelNum = 2000000

event/eventtype.go

@@ -10,14 +10,12 @@ const (
 	Sys_Event_Tcp         		EventType = -3
 	Sys_Event_Http_Event  		EventType = -4
 	Sys_Event_WebSocket       	EventType = -5
-	Sys_Event_Node_Conn_Event 	EventType = -6
-	Sys_Event_Nats_Conn_Event 	EventType = -7
-	Sys_Event_DiscoverService 	EventType = -8
-	Sys_Event_DiscardGoroutine 	EventType = -9
-	Sys_Event_QueueTaskFinish  	EventType = -10
-	Sys_Event_Retire       		EventType = -11
-	Sys_Event_EtcdDiscovery 	EventType = -12
-	
+	Sys_Event_Node_Event      	EventType = -6
+	Sys_Event_DiscoverService 	EventType = -7
+	Sys_Event_DiscardGoroutine 	EventType = -8
+	Sys_Event_QueueTaskFinish  	EventType = -9
+	Sys_Event_Retire       	EventType = -10
+
 	Sys_Event_User_Define 		EventType = 1
 )
 

go.mod

@@ -5,33 +5,22 @@ go 1.21
 require (
 	github.com/go-sql-driver/mysql v1.6.0
 	github.com/gomodule/redigo v1.8.8
-	github.com/google/uuid v1.6.0
 	github.com/gorilla/websocket v1.5.0
 	github.com/json-iterator/go v1.1.12
-	github.com/nats-io/nats.go v1.34.1
 	github.com/pierrec/lz4/v4 v4.1.18
 	github.com/shirou/gopsutil v3.21.11+incompatible
-	go.etcd.io/etcd/api/v3 v3.5.13
-	go.etcd.io/etcd/client/v3 v3.5.13
 	go.mongodb.org/mongo-driver v1.9.1
-	go.uber.org/zap v1.27.0
-	google.golang.org/protobuf v1.33.0
+	google.golang.org/protobuf v1.31.0
 	gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22
 )
 
 require (
-	github.com/coreos/go-semver v0.3.0 // indirect
-	github.com/coreos/go-systemd/v22 v22.3.2 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/go-stack/stack v1.8.0 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang/protobuf v1.5.4 // indirect
 	github.com/golang/snappy v0.0.1 // indirect
-	github.com/klauspost/compress v1.17.2 // indirect
+	github.com/klauspost/compress v1.13.6 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/nats-io/nkeys v0.4.7 // indirect
-	github.com/nats-io/nuid v1.0.1 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/tklauser/go-sysconf v0.3.13 // indirect
 	github.com/tklauser/numcpus v0.7.0 // indirect
@@ -40,15 +29,9 @@ require (
 	github.com/xdg-go/stringprep v1.0.2 // indirect
 	github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	go.etcd.io/etcd/client/pkg/v3 v3.5.13 // indirect
-	go.uber.org/multierr v1.10.0 // indirect
-	golang.org/x/crypto v0.18.0 // indirect
-	golang.org/x/net v0.17.0 // indirect
-	golang.org/x/sync v0.3.0 // indirect
-	golang.org/x/sys v0.16.0 // indirect
-	golang.org/x/text v0.14.0 // indirect
-	google.golang.org/genproto v0.0.0-20230822172742-b8732ec3820d // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20230822172742-b8732ec3820d // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d // indirect
-	google.golang.org/grpc v1.59.0 // indirect
+	golang.org/x/crypto v0.1.0 // indirect
+	golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9 // indirect
+	golang.org/x/sys v0.15.0 // indirect
+	golang.org/x/text v0.4.0 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
 )

go.sum

@@ -1,7 +1,3 @@
-github.com/coreos/go-semver v0.3.0 h1:wkHLiw0WNATZnSG7epLsujiMCgPAc9xhjJ4tgnAxmfM=
-github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
-github.com/coreos/go-systemd/v22 v22.3.2 h1:D9/bQk5vlXQFZ6Kwuu6zaiXJ9oTPe68++AzAJc1DzSI=
-github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -11,47 +7,31 @@ github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfC
 github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
 github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
-github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
-github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
-github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/gomodule/redigo v1.8.8 h1:f6cXq6RRfiyrOJEV7p3JhLDlmawGBVBBP1MggY8Mo4E=
 github.com/gomodule/redigo v1.8.8/go.mod h1:7ArFNvsTjH8GMMzB4uy1snslv2BwmginuMs06a1uzZE=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
 github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/klauspost/compress v1.13.6 h1:P76CopJELS0TiO2mebmnzgWaajssP/EszplttgQxcgc=
 github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
-github.com/klauspost/compress v1.17.2 h1:RlWWUY/Dr4fL8qk9YG7DTZ7PDgME2V4csBXA8L/ixi4=
-github.com/klauspost/compress v1.17.2/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
-github.com/nats-io/nats.go v1.34.1 h1:syWey5xaNHZgicYBemv0nohUPPmaLteiBEUT6Q5+F/4=
-github.com/nats-io/nats.go v1.34.1/go.mod h1:Ubdu4Nh9exXdSz0RVWRFBbRfrbSxOYd26oF0wkWclB8=
-github.com/nats-io/nkeys v0.4.7 h1:RwNJbbIdYCoClSDNY7QVKZlyb/wfT6ugvFCiKy6vDvI=
-github.com/nats-io/nkeys v0.4.7/go.mod h1:kqXRgRDPlGy7nGaEDMuYzmiJCIAAWDK0IMBtDmGD0nc=
-github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
-github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
 github.com/pierrec/lz4/v4 v4.1.18 h1:xaKrnTkyoqfh1YItXl56+6KJNVYWlEEPuAQW9xsplYQ=
 github.com/pierrec/lz4/v4 v4.1.18/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -63,9 +43,8 @@ github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMT
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/tidwall/pretty v1.0.0 h1:HsD+QiTn7sK6flMKIvNmpqz1qrpP3Ps6jOKIKMooyg4=
 github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
 github.com/tklauser/go-sysconf v0.3.13 h1:GBUpcahXSpR2xN01jhkNAbTLRk2Yzgggk8IM08lq3r4=
@@ -80,76 +59,37 @@ github.com/xdg-go/stringprep v1.0.2 h1:6iq84/ryjjeRmMJwxutI51F2GIPlP5BfTvXHeYjyh
 github.com/xdg-go/stringprep v1.0.2/go.mod h1:8F9zXuvzgwmyT5DUm4GUfZGDdT3W+LCvS6+da4O5kxM=
 github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d h1:splanxYIlg+5LfHAM6xpdFEAYOk8iySO56hMFq6uLyA=
 github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=
-github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
-go.etcd.io/etcd/api/v3 v3.5.13 h1:8WXU2/NBge6AUF1K1gOexB6e07NgsN1hXK0rSTtgSp4=
-go.etcd.io/etcd/api/v3 v3.5.13/go.mod h1:gBqlqkcMMZMVTMm4NDZloEVJzxQOQIls8splbqBDa0c=
-go.etcd.io/etcd/client/pkg/v3 v3.5.13 h1:RVZSAnWWWiI5IrYAXjQorajncORbS0zI48LQlE2kQWg=
-go.etcd.io/etcd/client/pkg/v3 v3.5.13/go.mod h1:XxHT4u1qU12E2+po+UVPrEeL94Um6zL58ppuJWXSAB8=
-go.etcd.io/etcd/client/v3 v3.5.13 h1:o0fHTNJLeO0MyVbc7I3fsCf6nrOqn5d+diSarKnB2js=
-go.etcd.io/etcd/client/v3 v3.5.13/go.mod h1:cqiAeY8b5DEEcpxvgWKsbLIWNM/8Wy2xJSDMtioMcoI=
 go.mongodb.org/mongo-driver v1.9.1 h1:m078y9v7sBItkt1aaoe2YlvWEXcD263e1a4E1fBrJ1c=
 go.mongodb.org/mongo-driver v1.9.1/go.mod h1:0sQWfOeY63QTntERDJJ/0SuKK0T1uVSgKCuAROlKEPY=
-go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
-go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ=
-go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
-go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
-go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20201216223049-8b5274cf687f/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc=
-golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
-golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/crypto v0.1.0 h1:MDRAIl0xIo9Io2xV565hzXHw3zVseKrJKodhohM5CjU=
+golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
-golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9 h1:SQFwaSi55rU7vdNs9Yr0Z324VNlrF+0wMqRXT4St8ck=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
-golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
-golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
+golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.4.0 h1:BrVqGRd7+k1DiOgtnFvAkoQEWQvBc25ouMJM6429SFg=
+golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190531172133-b3315ee88b7d/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/genproto v0.0.0-20230822172742-b8732ec3820d h1:VBu5YqKPv6XiJ199exd8Br+Aetz+o08F+PLMnwJQHAY=
-google.golang.org/genproto v0.0.0-20230822172742-b8732ec3820d/go.mod h1:yZTlhN0tQnXo3h00fuXNCxJdLdIdnVFVBaRJ5LWBbw4=
-google.golang.org/genproto/googleapis/api v0.0.0-20230822172742-b8732ec3820d h1:DoPTO70H+bcDXcd39vOqb2viZxgqeBeSGtZ55yZU4/Q=
-google.golang.org/genproto/googleapis/api v0.0.0-20230822172742-b8732ec3820d/go.mod h1:KjSP20unUpOx5kyQUFa7k4OJg0qeJ7DEZflGDu2p6Bk=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d h1:uvYuEyMHKNt+lT4K3bN6fGswmK8qSvcreM3BwjDh+y4=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d/go.mod h1:+Bk1OCOj40wS2hwAMA+aCW9ypzm63QTBBHp6lQ3p+9M=
-google.golang.org/grpc v1.59.0 h1:Z5Iec2pjwb+LEOqzpB2MR12/eKFhDPhuqW91O+4bwUk=
-google.golang.org/grpc v1.59.0/go.mod h1:aUPDwccQo6OTjy7Hct4AfBPD1GptF4fyUjIkQ9YtF98=
-google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
-google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -157,6 +97,5 @@ gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22 h1:VpOs+IwYnYBaFnrNAeB8UUWtL3
 gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22/go.mod h1:yeKp02qBN3iKW1OzL3MGk2IdtZzaj7SFntXj72NppTA=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

log/log.go

@@ -3,7 +3,7 @@ package log
 import (
 	"context"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/util/bytespool"
+	"github.com/duanhf2012/origin/util/bytespool"
 	jsoniter "github.com/json-iterator/go"
 	"io"
 	"log/slog"
@@ -22,7 +22,10 @@ var LogSize int64
 var LogChannelCap int
 var LogPath string
 var LogLevel slog.Level = LevelTrace
+
+
 var gLogger, _ = NewTextLogger(LevelDebug, "", "",true,LogChannelCap)
+var isSetLogger bool
 var memPool = bytespool.NewMemAreaPool()
 
 // levels
@@ -37,6 +40,21 @@ const (
 	LevelFatal 				= slog.Level(20)
 )
 
+type ILogger interface {
+	Trace(msg string, args ...any)
+	Debug(msg string, args ...any)
+	Info(msg string, args ...any)
+	Warning(msg string, args ...any)
+	Error(msg string, args ...any)
+	Stack(msg string, args ...any)
+	Dump(msg string, args ...any)
+	Fatal(msg string, args ...any)
+
+	DoSPrintf(level slog.Level,a []interface{})
+	FormatHeader(buf *Buffer,level slog.Level,calldepth int)
+	Close()
+}
+
 type Logger struct {
 	Slogger *slog.Logger
 
@@ -47,7 +65,6 @@ type Logger struct {
 
 type IoWriter struct {
 	outFile    io.Writer  // destination for output
-	outConsole io.Writer  //os.Stdout
 	writeBytes  int64
 	logChannel chan []byte
 	wg             sync.WaitGroup
@@ -122,8 +139,8 @@ func (iw *IoWriter) Write(p []byte) (n int, err error){
 func (iw *IoWriter) writeIo(p []byte)  (n int, err error){
 	n,err = iw.writeFile(p)
 
-	if iw.outConsole != nil {
-		n,err = iw.outConsole.Write(p)
+	if OpenConsole {
+		n,err = os.Stdout.Write(p)
 	}
 
 	return
@@ -217,17 +234,12 @@ func (iw *IoWriter) swichFile() error{
 		iw.fileDay = now.Day()
 		iw.fileCreateTime = now.Unix()
 		atomic.StoreInt64(&iw.writeBytes,0)
-		if OpenConsole == true {
-			iw.outConsole = os.Stdout
-		}
-	}else{
-		iw.outConsole = os.Stdout
 	}
 
 	return nil
 }
 
-func NewTextLogger(level slog.Level,pathName string,filePrefix string,addSource bool,logChannelCap int) (*Logger,error){
+func NewTextLogger(level slog.Level,pathName string,filePrefix string,addSource bool,logChannelCap int) (ILogger,error){
 	var logger Logger
 	logger.ioWriter.filePath = pathName
 	logger.ioWriter.fileprefix = filePrefix
@@ -242,7 +254,7 @@ func NewTextLogger(level slog.Level,pathName string,filePrefix string,addSource
 	return &logger,nil
 }
 
-func NewJsonLogger(level slog.Level,pathName string,filePrefix string,addSource bool,logChannelCap int) (*Logger,error){
+func NewJsonLogger(level slog.Level,pathName string,filePrefix string,addSource bool,logChannelCap int) (ILogger,error){
 	var logger Logger
 	logger.ioWriter.filePath = pathName
 	logger.ioWriter.fileprefix = filePrefix
@@ -296,13 +308,18 @@ func (logger *Logger) Fatal(msg string, args ...any) {
 	os.Exit(1)
 }
 
-// It's dangerous to call the method on logging
-func Export(logger *Logger) {
-	if logger != nil {
+// It's non-thread-safe
+func SetLogger(logger ILogger) {
+	if logger != nil && isSetLogger == false {
 		gLogger = logger
+		isSetLogger = true
 	}
 }
 
+func GetLogger() ILogger{
+	return gLogger
+}
+
 func Trace(msg string, args ...any){
 	gLogger.Trace(msg, args...)
 }
@@ -415,7 +432,7 @@ func Group(key string, args ...any) slog.Attr {
 	return slog.Group(key, args...)
 }
 
-func (logger *Logger) doSPrintf(level slog.Level,a []interface{}) {
+func (logger *Logger) DoSPrintf(level slog.Level,a []interface{}) {
 	if logger.Slogger.Enabled(context.Background(),level) == false{
 		return
 	}
@@ -425,7 +442,7 @@ func (logger *Logger) doSPrintf(level slog.Level,a []interface{}) {
 
 	logger.sBuff.Reset()
 
-	logger.formatHeader(&logger.sBuff,level,3)
+	logger.FormatHeader(&logger.sBuff,level,3)
 
 	for _,s := range a {
 		logger.sBuff.AppendString(slog.AnyValue(s).String())
@@ -435,46 +452,46 @@ func (logger *Logger) doSPrintf(level slog.Level,a []interface{}) {
 }
 
  func (logger *Logger) STrace(a ...interface{}) {
-	 logger.doSPrintf(LevelTrace,a)
+	 logger.DoSPrintf(LevelTrace,a)
 }
 
 func (logger *Logger)  SDebug(a ...interface{}) {
-	logger.doSPrintf(LevelDebug,a)
+	logger.DoSPrintf(LevelDebug,a)
 }
 
 func (logger *Logger)  SInfo(a ...interface{}) {
-	logger.doSPrintf(LevelInfo,a)
+	logger.DoSPrintf(LevelInfo,a)
 }
 
 func (logger *Logger)  SWarning(a ...interface{}) {
-	logger.doSPrintf(LevelWarning,a)
+	logger.DoSPrintf(LevelWarning,a)
 }
 
 func (logger *Logger)  SError(a ...interface{}) {
-	logger.doSPrintf(LevelError,a)
+	logger.DoSPrintf(LevelError,a)
 }
 
 func STrace(a ...interface{}) {
-	gLogger.doSPrintf(LevelTrace,a)
+	gLogger.DoSPrintf(LevelTrace,a)
 }
 
 func SDebug(a ...interface{}) {
-	gLogger.doSPrintf(LevelDebug,a)
+	gLogger.DoSPrintf(LevelDebug,a)
 }
 
 func SInfo(a ...interface{}) {
-	gLogger.doSPrintf(LevelInfo,a)
+	gLogger.DoSPrintf(LevelInfo,a)
 }
 
 func SWarning(a ...interface{}) {
-	gLogger.doSPrintf(LevelWarning,a)
+	gLogger.DoSPrintf(LevelWarning,a)
 }
 
 func SError(a ...interface{}) {
-	gLogger.doSPrintf(LevelError,a)
+	gLogger.DoSPrintf(LevelError,a)
 }
 
-func (logger *Logger) formatHeader(buf *Buffer,level slog.Level,calldepth int) {
+func (logger *Logger) FormatHeader(buf *Buffer,level slog.Level,calldepth int) {
 	t := time.Now()
 	var file string
 	var line int

network/http_server.go

@@ -3,7 +3,7 @@ package network
 import (
 	"crypto/tls"
 	"errors"
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"net/http"
 	"time"
 )

network/processor/jsonprocessor.go

@@ -3,8 +3,8 @@ package processor
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/util/bytespool"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/util/bytespool"
 	"reflect"
 )
 
@@ -13,9 +13,9 @@ type MessageJsonInfo struct {
 	msgHandler MessageJsonHandler
 }
 
-type MessageJsonHandler func(clientId string,msg interface{})
-type ConnectJsonHandler func(clientId string)
-type UnknownMessageJsonHandler func(clientId string,msg []byte)
+type MessageJsonHandler func(clientId uint64,msg interface{})
+type ConnectJsonHandler func(clientId uint64)
+type UnknownMessageJsonHandler func(clientId uint64,msg []byte)
 
 type JsonProcessor struct {
 	mapMsg map[uint16]MessageJsonInfo
@@ -45,7 +45,7 @@ func (jsonProcessor *JsonProcessor) SetByteOrder(littleEndian bool) {
 }
 
 // must goroutine safe
-func (jsonProcessor *JsonProcessor ) MsgRoute(clientId string,msg interface{}) error{
+func (jsonProcessor *JsonProcessor ) MsgRoute(clientId uint64,msg interface{}) error{
 	pPackInfo := msg.(*JsonPackInfo)
 	v,ok := jsonProcessor.mapMsg[pPackInfo.typ]
 	if ok == false {
@@ -56,7 +56,7 @@ func (jsonProcessor *JsonProcessor ) MsgRoute(clientId string,msg interface{}) e
 	return nil
 }
 
-func (jsonProcessor *JsonProcessor) Unmarshal(clientId string,data []byte) (interface{}, error) {
+func (jsonProcessor *JsonProcessor) Unmarshal(clientId uint64,data []byte) (interface{}, error) {
 	typeStruct := struct {Type int `json:"typ"`}{}
 	defer jsonProcessor.ReleaseBytes(data)
 	err := json.Unmarshal(data, &typeStruct)
@@ -79,7 +79,7 @@ func (jsonProcessor *JsonProcessor) Unmarshal(clientId string,data []byte) (inte
 	return &JsonPackInfo{typ:msgType,msg:msgData},nil
 }
 
-func (jsonProcessor *JsonProcessor) Marshal(clientId string,msg interface{}) ([]byte, error) {
+func (jsonProcessor *JsonProcessor) Marshal(clientId uint64,msg interface{}) ([]byte, error) {
 	rawMsg,err := json.Marshal(msg)
 	if err != nil {
 		return nil,err
@@ -104,9 +104,9 @@ 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 uint64,msg interface{}){
 	if jsonProcessor.unknownMessageHandler==nil {
-		log.Debug("Unknown message",log.String("clientId",clientId))
+		log.Debug("Unknown message",log.Uint64("clientId",clientId))
 		return
 	}
 
@@ -114,13 +114,13 @@ func (jsonProcessor *JsonProcessor) UnknownMsgRoute(clientId string,msg interfac
 
 }
 
-func (jsonProcessor *JsonProcessor) ConnectedRoute(clientId string){
+func (jsonProcessor *JsonProcessor) ConnectedRoute(clientId uint64){
 	if jsonProcessor.connectHandler != nil {
 		jsonProcessor.connectHandler(clientId)
 	}
 }
 
-func (jsonProcessor *JsonProcessor) DisConnectedRoute(clientId string){
+func (jsonProcessor *JsonProcessor) DisConnectedRoute(clientId uint64){
 	if jsonProcessor.disconnectHandler != nil {
 		jsonProcessor.disconnectHandler(clientId)
 	}

network/processor/pbprocessor.go

@@ -3,7 +3,7 @@ package processor
 import (
 	"encoding/binary"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/util/bytespool"
+	"github.com/duanhf2012/origin/util/bytespool"
 	"google.golang.org/protobuf/proto"
 	"reflect"
 )
@@ -13,9 +13,9 @@ type MessageInfo struct {
 	msgHandler MessageHandler
 }
 
-type MessageHandler func(clientId string, msg proto.Message)
-type ConnectHandler func(clientId string)
-type UnknownMessageHandler func(clientId string, msg []byte)
+type MessageHandler func(clientId uint64, msg proto.Message)
+type ConnectHandler func(clientId uint64)
+type UnknownMessageHandler func(clientId uint64, msg []byte)
 
 const MsgTypeSize = 2
 
@@ -54,7 +54,7 @@ func (slf *PBPackInfo) GetMsg() proto.Message {
 }
 
 // must goroutine safe
-func (pbProcessor *PBProcessor) MsgRoute(clientId string, msg interface{}) error {
+func (pbProcessor *PBProcessor) MsgRoute(clientId uint64, msg interface{}) error {
 	pPackInfo := msg.(*PBPackInfo)
 	v, ok := pbProcessor.mapMsg[pPackInfo.typ]
 	if ok == false {
@@ -66,13 +66,13 @@ func (pbProcessor *PBProcessor) MsgRoute(clientId string, msg interface{}) error
 }
 
 // must goroutine safe
-func (pbProcessor *PBProcessor) Unmarshal(clientId string, data []byte) (interface{}, error) {
+func (pbProcessor *PBProcessor) Unmarshal(clientId uint64, data []byte) (interface{}, error) {
 	defer pbProcessor.ReleaseBytes(data)
 	return pbProcessor.UnmarshalWithOutRelease(clientId, data)
 }
 
 // unmarshal but not release data
-func (pbProcessor *PBProcessor) UnmarshalWithOutRelease(clientId string, data []byte) (interface{}, error) {
+func (pbProcessor *PBProcessor) UnmarshalWithOutRelease(clientId uint64, data []byte) (interface{}, error) {
 	var msgType uint16
 	if pbProcessor.LittleEndian == true {
 		msgType = binary.LittleEndian.Uint16(data[:2])
@@ -95,7 +95,7 @@ func (pbProcessor *PBProcessor) UnmarshalWithOutRelease(clientId string, data []
 }
 
 // must goroutine safe
-func (pbProcessor *PBProcessor) Marshal(clientId string, msg interface{}) ([]byte, error) {
+func (pbProcessor *PBProcessor) Marshal(clientId uint64, msg interface{}) ([]byte, error) {
 	pMsg := msg.(*PBPackInfo)
 
 	var err error
@@ -133,16 +133,16 @@ 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 uint64, msg interface{}) {
 	pbProcessor.unknownMessageHandler(clientId, msg.([]byte))
 }
 
 // connect event
-func (pbProcessor *PBProcessor) ConnectedRoute(clientId string) {
+func (pbProcessor *PBProcessor) ConnectedRoute(clientId uint64) {
 	pbProcessor.connectHandler(clientId)
 }
 
-func (pbProcessor *PBProcessor) DisConnectedRoute(clientId string) {
+func (pbProcessor *PBProcessor) DisConnectedRoute(clientId uint64) {
 	pbProcessor.disconnectHandler(clientId)
 }
 

network/processor/processor.go

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

network/tcp_client.go

@@ -1,7 +1,7 @@
 package network
 
 import (
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"net"
 	"sync"
 	"time"

network/tcp_conn.go

@@ -2,7 +2,7 @@ package network
 
 import (
 	"errors"
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"net"
 	"sync"
 	"sync/atomic"

network/tcp_msg.go

@@ -3,7 +3,7 @@ package network
 import (
 	"encoding/binary"
 	"errors"
-	"github.com/duanhf2012/origin/v2/util/bytespool"
+	"github.com/duanhf2012/origin/util/bytespool"
 	"io"
 	"math"
 )

network/tcp_server.go

@@ -1,13 +1,11 @@
 package network
 
 import (
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/util/bytespool"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/util/bytespool"
 	"net"
 	"sync"
 	"time"
-	"fmt"
-	"errors"
 )
 
 const(
@@ -38,20 +36,15 @@ type TCPServer struct {
 	MsgParser
 }
 
-func (server *TCPServer) Start() error{
-	err := server.init()
-	if err != nil {
-		return err
-	}
+func (server *TCPServer) Start() {
+	server.init()
 	go server.run()
-
-	return nil
 }
 
-func (server *TCPServer) init() error{
+func (server *TCPServer) init() {
 	ln, err := net.Listen("tcp", server.Addr)
 	if err != nil {
-		return fmt.Errorf("Listen tcp fail,error:%s",err.Error())
+		log.Fatal("Listen tcp fail",log.String("error", err.Error()))
 	}
 
 	if server.MaxConnNum <= 0 {
@@ -96,14 +89,12 @@ func (server *TCPServer) init() error{
 	}
 
 	if server.NewAgent == nil {
-		return errors.New("NewAgent must not be nil")
+		log.Fatal("NewAgent must not be nil")
 	}
 
 	server.ln = ln
 	server.conns = make(ConnSet)
 	server.MsgParser.init()
-	
-	return nil
 }
 
 func (server *TCPServer) SetNetMempool(mempool bytespool.IBytesMempool){

network/ws_client.go

@@ -1,7 +1,7 @@
 package network
 
 import (
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"github.com/gorilla/websocket"
 	"sync"
 	"time"

network/ws_conn.go

@@ -2,7 +2,7 @@ package network
 
 import (
 	"errors"
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"github.com/gorilla/websocket"
 	"net"
 	"sync"

network/ws_server.go

@@ -2,7 +2,7 @@ package network
 
 import (
 	"crypto/tls"
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"github.com/gorilla/websocket"
 	"net"
 	"net/http"

node/node.go

@@ -3,13 +3,13 @@ package node
 import (
 	"errors"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/cluster"
-	"github.com/duanhf2012/origin/v2/console"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/profiler"
-	"github.com/duanhf2012/origin/v2/service"
-	"github.com/duanhf2012/origin/v2/util/buildtime"
-	"github.com/duanhf2012/origin/v2/util/timer"
+	"github.com/duanhf2012/origin/cluster"
+	"github.com/duanhf2012/origin/console"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/profiler"
+	"github.com/duanhf2012/origin/service"
+	"github.com/duanhf2012/origin/util/buildtime"
+	"github.com/duanhf2012/origin/util/timer"
 	"io"
 	"net/http"
 	_ "net/http/pprof"
@@ -19,11 +19,11 @@ import (
 	"strings"
 	"syscall"
 	"time"
-	"github.com/duanhf2012/origin/v2/util/sysprocess"
+	"github.com/duanhf2012/origin/util/sysprocess"
 )
 
 var sig chan os.Signal
-var nodeId string
+var nodeId int
 var preSetupService []service.IService //预安装
 var profilerInterval time.Duration
 var bValid bool
@@ -116,7 +116,7 @@ func setConfigPath(val interface{}) error {
 	return nil
 }
 
-func getRunProcessPid(nodeId string) (int, error) {
+func getRunProcessPid(nodeId int) (int, error) {
 	f, err := os.OpenFile(fmt.Sprintf("%s_%d.pid", os.Args[0], nodeId), os.O_RDONLY, 0600)
 	defer f.Close()
 	if err != nil {
@@ -131,9 +131,9 @@ func getRunProcessPid(nodeId string) (int, error) {
 	return strconv.Atoi(string(pidByte))
 }
 
-func writeProcessPid(nodeId string) {
+func writeProcessPid(nodeId int) {
 	//pid
-	f, err := os.OpenFile(fmt.Sprintf("%s_%s.pid", os.Args[0], nodeId), os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0600)
+	f, err := os.OpenFile(fmt.Sprintf("%s_%d.pid", os.Args[0], nodeId), os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0600)
 	defer f.Close()
 	if err != nil {
 		fmt.Println(err.Error())
@@ -147,17 +147,16 @@ func writeProcessPid(nodeId string) {
 	}
 }
 
-func GetNodeId() string {
+func GetNodeId() int {
 	return nodeId
 }
 
-func initNode(id string) {
+func initNode(id int) {
 	//1.初始化集群
 	nodeId = id
 	err := cluster.GetCluster().Init(GetNodeId(), Setup)
 	if err != nil {
-		log.Error("Init cluster fail",log.ErrorAttr("error",err))
-		os.Exit(1)
+		log.Fatal("read system config is error ",log.ErrorAttr("error",err))
 	}
 
 	err = initLog()
@@ -195,13 +194,13 @@ func initLog() error {
 	}
 
 	localnodeinfo := cluster.GetCluster().GetLocalNodeInfo()
-	filepre := fmt.Sprintf("%s_", localnodeinfo.NodeId)
+	filepre := fmt.Sprintf("%s_%d_", localnodeinfo.NodeName, localnodeinfo.NodeId)
 	logger, err := log.NewTextLogger(log.LogLevel,log.LogPath,filepre,true,log.LogChannelCap)
 	if err != nil {
 		fmt.Printf("cannot create log file!\n")
 		return err
 	}
-	log.Export(logger)
+	log.SetLogger(logger)
 	return nil
 }
 
@@ -228,8 +227,8 @@ func retireNode(args interface{}) error {
 	if sParam[0] != "nodeid" {
 		return fmt.Errorf("invalid option %s", param)
 	}
-	nId := strings.TrimSpace(sParam[1])
-	if nId == "" {
+	nId, err := strconv.Atoi(sParam[1])
+	if err != nil {
 		return fmt.Errorf("invalid option %s", param)
 	}
 
@@ -258,8 +257,8 @@ func stopNode(args interface{}) error {
 	if sParam[0] != "nodeid" {
 		return fmt.Errorf("invalid option %s", param)
 	}
-	nId := strings.TrimSpace(sParam[1])
-	if nId == "" {
+	nId, err := strconv.Atoi(sParam[1])
+	if err != nil {
 		return fmt.Errorf("invalid option %s", param)
 	}
 
@@ -286,13 +285,12 @@ func startNode(args interface{}) error {
 	if sParam[0] != "nodeid" {
 		return fmt.Errorf("invalid option %s", param)
 	}
-	strNodeId := strings.TrimSpace(sParam[1])
-	if strNodeId == "" {
+	nodeId, err := strconv.Atoi(sParam[1])
+	if err != nil {
 		return fmt.Errorf("invalid option %s", param)
 	}
-
 	for{
-		processId, pErr := getRunProcessPid(strNodeId)
+		processId, pErr := getRunProcessPid(nodeId)
 		if pErr != nil {
 			break
 		}
@@ -301,13 +299,13 @@ func startNode(args interface{}) error {
 		myName, mErr := sysprocess.GetMyProcessName()
 		//当前进程名获取失败，不应该发生
 		if mErr != nil {
-			log.SInfo("get my process's name is error,", mErr.Error())
+			log.SInfo("get my process's name is error,", err.Error())
 			os.Exit(-1)
 		}
 
 		//进程id存在，而且进程名也相同，被认为是当前进程重复运行
 		if cErr == nil && name == myName {
-			log.SInfo(fmt.Sprintf("repeat runs are not allowed,node is %s,processid is %d",strNodeId,processId))
+			log.SInfo(fmt.Sprintf("repeat runs are not allowed,node is %d,processid is %d",nodeId,processId))
 			os.Exit(-1)
 		}
 		break
@@ -315,18 +313,20 @@ func startNode(args interface{}) error {
 
 	//2.记录进程id号
 	log.Info("Start running server.")
-	writeProcessPid(strNodeId)
+	writeProcessPid(nodeId)
 	timer.StartTimer(10*time.Millisecond, 1000000)
 
 	//3.初始化node
-	initNode(strNodeId)
+	initNode(nodeId)
 
 	//4.运行service
 	service.Start()
 
 	//5.运行集群
 	cluster.GetCluster().Start()
-	
+
+
+
 	//6.监听程序退出信号&性能报告
 	bRun := true
 	var pProfilerTicker *time.Ticker = &time.Ticker{}
@@ -350,10 +350,9 @@ func startNode(args interface{}) error {
 		}
 	}
 
-
+	cluster.GetCluster().Stop()
 	//7.退出
 	service.StopAllService()
-	cluster.GetCluster().Stop()
 
 	log.Info("Server is stop.")
 	log.Close()

profiler/profiler.go

@@ -3,7 +3,7 @@ package profiler
 import (
 	"container/list"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"sync"
 	"time"
 )

rpc/callset.go

@@ -1,146 +0,0 @@
-package rpc
-
-import (
-	"errors"
-
-	"strconv"
-	"sync"
-	"sync/atomic"
-	"time"
-	"github.com/duanhf2012/origin/v2/log"
-)
-
-type CallSet struct {
-	pendingLock          sync.RWMutex
-	startSeq             uint64
-	pending              map[uint64]*Call
-	callRpcTimeout       time.Duration
-	maxCheckCallRpcCount int
-
-	callTimerHeap CallTimerHeap
-}
-
-
-
-func (cs *CallSet) Init(){
-	cs.pendingLock.Lock()
-	cs.callTimerHeap.Init()
-	cs.pending = make(map[uint64]*Call,4096)
-
-	cs.maxCheckCallRpcCount = DefaultMaxCheckCallRpcCount
-	cs.callRpcTimeout = DefaultRpcTimeout
-
-	go cs.checkRpcCallTimeout()
-	cs.pendingLock.Unlock()
-}
-
-func (bc *CallSet) makeCallFail(call *Call) {
-	if call.callback != nil && call.callback.IsValid() {
-		call.rpcHandler.PushRpcResponse(call)
-	} else {
-		call.done <- call
-	}
-}
-
-func (bc *CallSet) checkRpcCallTimeout() {
-	for{
-		time.Sleep(DefaultCheckRpcCallTimeoutInterval)
-		for i := 0; i < bc.maxCheckCallRpcCount; i++ {
-			bc.pendingLock.Lock()
-
-			callSeq := bc.callTimerHeap.PopTimeout()
-			if callSeq == 0 {
-				bc.pendingLock.Unlock()
-				break
-			}
-
-			pCall := bc.pending[callSeq]
-			if pCall == nil {
-				bc.pendingLock.Unlock()
-				log.Error("call seq is not find",log.Uint64("seq", callSeq))
-				continue
-			}
-
-			delete(bc.pending,callSeq)
-			strTimeout := strconv.FormatInt(int64(pCall.TimeOut.Seconds()), 10)
-			pCall.Err = errors.New("RPC call takes more than " + strTimeout + " seconds,method is "+pCall.ServiceMethod)
-			log.Error("call timeout",log.String("error",pCall.Err.Error()))
-			bc.makeCallFail(pCall)
-			bc.pendingLock.Unlock()
-			continue
-		}
-	}
-}
-
-func (bc *CallSet) AddPending(call *Call) {
-	bc.pendingLock.Lock()
-
-	if call.Seq == 0 {
-		bc.pendingLock.Unlock()
-		log.Stack("call is error.")
-		return
-	}
-
-	bc.pending[call.Seq] = call
-	bc.callTimerHeap.AddTimer(call.Seq,call.TimeOut)
-
-	bc.pendingLock.Unlock()
-}
-
-func (bc *CallSet) RemovePending(seq uint64) *Call {
-	if seq == 0  {
-		return nil
-	}
-	bc.pendingLock.Lock()
-	call := bc.removePending(seq)
-	bc.pendingLock.Unlock()
-	return call
-}
-
-func (bc *CallSet) removePending(seq uint64) *Call {
-	v, ok := bc.pending[seq]
-	if ok == false {
-		return nil
-	}
-
-	bc.callTimerHeap.Cancel(seq)
-	delete(bc.pending, seq)
-	return v
-}
-
-func (bc *CallSet) FindPending(seq uint64) (pCall *Call) {
-	if seq == 0 {
-		return nil
-	}
-
-	bc.pendingLock.Lock()
-	pCall = bc.pending[seq]
-	bc.pendingLock.Unlock()
-
-	return pCall
-}
-
-func (bc *CallSet) cleanPending(){
-	bc.pendingLock.Lock()
-	for  {
-		callSeq := bc.callTimerHeap.PopFirst()
-		if callSeq == 0 {
-			break
-		}
-		pCall := bc.pending[callSeq]
-		if pCall == nil {
-			log.Error("call Seq is not find",log.Uint64("seq",callSeq))
-			continue
-		}
-
-		delete(bc.pending,callSeq)
-		pCall.Err = errors.New("nodeid is disconnect ")
-		bc.makeCallFail(pCall)
-	}
-
-	bc.pendingLock.Unlock()
-}
-
-func (bc *CallSet) generateSeq() uint64 {
-	return atomic.AddUint64(&bc.startSeq, 1)
-}

rpc/client.go

@@ -2,11 +2,13 @@ package rpc
 
 import (
 	"errors"
-	"github.com/duanhf2012/origin/v2/network"
+	"github.com/duanhf2012/origin/network"
 	"reflect"
+	"strconv"
+	"sync"
+	"sync/atomic"
 	"time"
-	"github.com/duanhf2012/origin/v2/log"
-	"fmt"
+	"github.com/duanhf2012/origin/log"
 )
 
 const(
@@ -14,7 +16,8 @@ const(
 	DefaultRpcLenMsgLen         = 4
 	DefaultRpcMinMsgLen         = 2
 	DefaultMaxCheckCallRpcCount = 1000
-	DefaultMaxPendingWriteNum 	 = 1000000
+	DefaultMaxPendingWriteNum 	 = 200000
+
 
 	DefaultConnectInterval = 2*time.Second
 	DefaultCheckRpcCallTimeoutInterval = 1*time.Second
@@ -23,34 +26,29 @@ const(
 
 var clientSeq uint32
 
-type IWriter interface {
-	WriteMsg (nodeId string,args ...[]byte) error
-	IsConnected() bool
-}
-
 type IRealClient interface {
 	SetConn(conn *network.TCPConn)
 	Close(waitDone bool)
 
-	AsyncCall(NodeId string,timeout time.Duration,rpcHandler IRpcHandler, serviceMethod string, callback reflect.Value, args interface{}, replyParam interface{},cancelable bool)  (CancelRpc,error)
-	Go(NodeId string,timeout time.Duration,rpcHandler IRpcHandler, noReply bool, serviceMethod string, args interface{}, reply interface{}) *Call
-	RawGo(NodeId string,timeout time.Duration,rpcHandler IRpcHandler,processor IRpcProcessor, noReply bool, rpcMethodId uint32, serviceMethod string, rawArgs []byte, reply interface{}) *Call
+	AsyncCall(timeout time.Duration,rpcHandler IRpcHandler, serviceMethod string, callback reflect.Value, args interface{}, replyParam interface{},cancelable bool)  (CancelRpc,error)
+	Go(timeout time.Duration,rpcHandler IRpcHandler, noReply bool, serviceMethod string, args interface{}, reply interface{}) *Call
+	RawGo(timeout time.Duration,rpcHandler IRpcHandler,processor IRpcProcessor, noReply bool, rpcMethodId uint32, serviceMethod string, rawArgs []byte, reply interface{}) *Call
 	IsConnected() bool
 
 	Run()
 	OnClose()
-
-	Bind(server IServer)
 }
 
-
-
 type Client struct {
-	clientId             uint32
-	targetNodeId               string
-	compressBytesLen int
+	clientId 		uint32
+	nodeId        int
+	pendingLock          sync.RWMutex
+	startSeq             uint64
+	pending              map[uint64]*Call
+	callRpcTimeout       time.Duration
+	maxCheckCallRpcCount int
 
-	*CallSet
+	callTimerHeap CallTimerHeap
 	IRealClient
 }
 
@@ -60,218 +58,128 @@ func (client *Client) NewClientAgent(conn *network.TCPConn) network.Agent {
 	return client
 }
 
-func (client *Client) GetTargetNodeId() string {
-	return client.targetNodeId
+func (bc *Client) makeCallFail(call *Call) {
+	if call.callback != nil && call.callback.IsValid() {
+		call.rpcHandler.PushRpcResponse(call)
+	} else {
+		call.done <- call
+	}
+}
+
+func (bc *Client) checkRpcCallTimeout() {
+	for{
+		time.Sleep(DefaultCheckRpcCallTimeoutInterval)
+		for i := 0; i < bc.maxCheckCallRpcCount; i++ {
+			bc.pendingLock.Lock()
+			
+			callSeq := bc.callTimerHeap.PopTimeout()
+			if callSeq == 0 {
+				bc.pendingLock.Unlock()
+				break
+			}
+
+			pCall := bc.pending[callSeq]
+			if pCall == nil {
+				bc.pendingLock.Unlock()
+				log.Error("call seq is not find",log.Uint64("seq", callSeq))
+				continue
+			}
+
+			delete(bc.pending,callSeq)
+			strTimeout := strconv.FormatInt(int64(pCall.TimeOut.Seconds()), 10)
+			pCall.Err = errors.New("RPC call takes more than " + strTimeout + " seconds,method is "+pCall.ServiceMethod)
+			log.Error("call timeout",log.String("error",pCall.Err.Error()))
+			bc.makeCallFail(pCall)
+			bc.pendingLock.Unlock()
+			continue
+		}
+	}
+}
+
+func (client *Client) InitPending() {
+	client.pendingLock.Lock()
+	client.callTimerHeap.Init()
+	client.pending = make(map[uint64]*Call,4096)
+	client.pendingLock.Unlock()
+}
+
+func (bc *Client) AddPending(call *Call) {
+	bc.pendingLock.Lock()
+
+	if call.Seq == 0 {
+		bc.pendingLock.Unlock()
+		log.Stack("call is error.")
+		return
+	}
+
+	bc.pending[call.Seq] = call
+	bc.callTimerHeap.AddTimer(call.Seq,call.TimeOut)
+
+	bc.pendingLock.Unlock()
+}
+
+func (bc *Client) RemovePending(seq uint64) *Call {
+	if seq == 0  {
+		return nil
+	}
+	bc.pendingLock.Lock()
+	call := bc.removePending(seq)
+	bc.pendingLock.Unlock()
+	return call
+}
+
+func (bc *Client) removePending(seq uint64) *Call {
+	v, ok := bc.pending[seq]
+	if ok == false {
+		return nil
+	}
+
+	bc.callTimerHeap.Cancel(seq)
+	delete(bc.pending, seq)
+	return v
+}
+
+func (bc *Client) FindPending(seq uint64) (pCall *Call) {
+	if seq == 0 {
+		return nil
+	}
+	
+	bc.pendingLock.Lock()
+	pCall = bc.pending[seq]
+	bc.pendingLock.Unlock()
+
+	return pCall
+}
+
+func (bc *Client) cleanPending(){
+	bc.pendingLock.Lock()
+	for  {
+		callSeq := bc.callTimerHeap.PopFirst()
+		if callSeq == 0 {
+			break
+		}
+		pCall := bc.pending[callSeq]
+		if pCall == nil {
+			log.Error("call Seq is not find",log.Uint64("seq",callSeq))
+			continue
+		}
+
+		delete(bc.pending,callSeq)
+		pCall.Err = errors.New("nodeid is disconnect ")
+		bc.makeCallFail(pCall)
+	}
+
+	bc.pendingLock.Unlock()
+}
+
+func (bc *Client) generateSeq() uint64 {
+	return atomic.AddUint64(&bc.startSeq, 1)
+}
+
+func (client *Client) GetNodeId() int {
+	return client.nodeId
 }
 
 func (client *Client) GetClientId() uint32 {
 	return client.clientId
 }
-
-
-func (client *Client) processRpcResponse(responseData []byte) error{
-	bCompress := (responseData[0]>>7) > 0
-	processor := GetProcessor(responseData[0]&0x7f)
-	if processor == nil {
-		//rc.conn.ReleaseReadMsg(responseData)
-		err:= errors.New(fmt.Sprintf("cannot find process %d",responseData[0]&0x7f))
-		log.Error(err.Error())
-		return err
-	}
-
-	//1.解析head
-	response := RpcResponse{}
-	response.RpcResponseData = processor.MakeRpcResponse(0, "", nil)
-
-	//解压缩
-	byteData := responseData[1:]
-	var compressBuff []byte
-
-	if bCompress == true {
-		var unCompressErr error
-		compressBuff,unCompressErr = compressor.UncompressBlock(byteData)
-		if unCompressErr!= nil {
-			//rc.conn.ReleaseReadMsg(responseData)
-			err := fmt.Errorf("uncompressBlock failed,err :%s",unCompressErr.Error())
-			return err
-		}
-
-		byteData = compressBuff
-	}
-
-	err := processor.Unmarshal(byteData, response.RpcResponseData)
-	if cap(compressBuff) > 0 {
-		compressor.UnCompressBufferCollection(compressBuff)
-	}
-
-	//rc.conn.ReleaseReadMsg(bytes)
-	if err != nil {
-		processor.ReleaseRpcResponse(response.RpcResponseData)
-		log.Error("rpcClient Unmarshal head error",log.ErrorAttr("error",err))
-		return nil
-	}
-
-	v := client.RemovePending(response.RpcResponseData.GetSeq())
-	if v == nil {
-		log.Error("rpcClient cannot find seq",log.Uint64("seq",response.RpcResponseData.GetSeq()))
-	} else {
-		v.Err = nil
-		if len(response.RpcResponseData.GetReply()) > 0 {
-			err = processor.Unmarshal(response.RpcResponseData.GetReply(), v.Reply)
-			if err != nil {
-				log.Error("rpcClient Unmarshal body failed",log.ErrorAttr("error",err))
-				v.Err = err
-			}
-		}
-
-		if response.RpcResponseData.GetErr() != nil {
-			v.Err = response.RpcResponseData.GetErr()
-		}
-
-		if v.callback != nil && v.callback.IsValid() {
-			v.rpcHandler.PushRpcResponse(v)
-		} else {
-			v.done <- v
-		}
-	}
-
-	processor.ReleaseRpcResponse(response.RpcResponseData)
-
-	return nil
-}
-
-
-//func (rc *Client) Go(timeout time.Duration,rpcHandler IRpcHandler,noReply bool, serviceMethod string, args interface{}, reply interface{}) *Call {
-//	_, processor := GetProcessorType(args)
-//	InParam, err := processor.Marshal(args)
-//	if err != nil {
-//		log.Error("Marshal is fail",log.ErrorAttr("error",err))
-//		call := MakeCall()
-//		call.DoError(err)
-//		return call
-//	}
-//
-//	return rc.RawGo(timeout,rpcHandler,processor, noReply, 0, serviceMethod, InParam, reply)
-//}
-
-func (rc *Client) rawGo(nodeId string,w IWriter,timeout time.Duration,rpcHandler IRpcHandler,processor IRpcProcessor, noReply bool, rpcMethodId uint32, serviceMethod string, rawArgs []byte, reply interface{}) *Call {
-	call := MakeCall()
-	call.ServiceMethod = serviceMethod
-	call.Reply = reply
-	call.Seq = rc.generateSeq()
-	call.TimeOut = timeout
-
-	request := MakeRpcRequest(processor, call.Seq, rpcMethodId, serviceMethod, noReply, rawArgs)
-	bytes, err := processor.Marshal(request.RpcRequestData)
-	ReleaseRpcRequest(request)
-
-	if err != nil {
-		call.Seq = 0
-		log.Error("marshal is fail",log.String("error",err.Error()))
-		call.DoError(err)
-		return call
-	}
-
-	if w == nil || w.IsConnected()==false {
-		call.Seq = 0
-		sErr := errors.New(serviceMethod + "  was called failed,rpc client is disconnect")
-		log.Error("conn is disconnect",log.String("error",sErr.Error()))
-		call.DoError(sErr)
-		return call
-	}
-
-	var compressBuff[]byte
-	bCompress := uint8(0)
-	if rc.compressBytesLen > 0 && len(bytes) >= rc.compressBytesLen {
-		var cErr error
-		compressBuff,cErr = compressor.CompressBlock(bytes)
-		if cErr != nil {
-			call.Seq = 0
-			log.Error("compress fail",log.String("error",cErr.Error()))
-			call.DoError(cErr)
-			return call
-		}
-		if len(compressBuff) < len(bytes) {
-			bytes = compressBuff
-			bCompress = 1<<7
-		}
-	}
-
-	if noReply == false {
-		rc.AddPending(call)
-	}
-
-	err = w.WriteMsg(nodeId,[]byte{uint8(processor.GetProcessorType())|bCompress}, bytes)
-	if cap(compressBuff) >0 {
-		compressor.CompressBufferCollection(compressBuff)
-	}
-	if err != nil {
-		rc.RemovePending(call.Seq)
-		log.Error("WiteMsg is fail",log.ErrorAttr("error",err))
-		call.Seq = 0
-		call.DoError(err)
-	}
-
-	return call
-}
-
-func (rc *Client) asyncCall(nodeId string,w IWriter,timeout time.Duration,rpcHandler IRpcHandler, serviceMethod string, callback reflect.Value, args interface{}, replyParam interface{},cancelable bool) (CancelRpc,error) {
-	processorType, processor := GetProcessorType(args)
-	InParam, herr := processor.Marshal(args)
-	if herr != nil {
-		return emptyCancelRpc,herr
-	}
-
-	seq := rc.generateSeq()
-	request := MakeRpcRequest(processor, seq, 0, serviceMethod, false, InParam)
-	bytes, err := processor.Marshal(request.RpcRequestData)
-	ReleaseRpcRequest(request)
-	if err != nil {
-		return emptyCancelRpc,err
-	}
-
-	if w == nil || w.IsConnected()==false {
-		return emptyCancelRpc,errors.New("Rpc server is disconnect,call " + serviceMethod)
-	}
-
-	var compressBuff[]byte
-	bCompress := uint8(0)
-	if rc.compressBytesLen>0 &&len(bytes) >= rc.compressBytesLen {
-		var cErr error
-		compressBuff,cErr = compressor.CompressBlock(bytes)
-		if cErr != nil {
-			return emptyCancelRpc,cErr
-		}
-
-		if len(compressBuff) < len(bytes) {
-			bytes = compressBuff
-			bCompress = 1<<7
-		}
-	}
-
-	call := MakeCall()
-	call.Reply = replyParam
-	call.callback = &callback
-	call.rpcHandler = rpcHandler
-	call.ServiceMethod = serviceMethod
-	call.Seq = seq
-	call.TimeOut = timeout
-	rc.AddPending(call)
-
-	err = w.WriteMsg(nodeId,[]byte{uint8(processorType)|bCompress}, bytes)
-	if cap(compressBuff) >0 {
-		compressor.CompressBufferCollection(compressBuff)
-	}
-	if err != nil {
-		rc.RemovePending(call.Seq)
-		ReleaseCall(call)
-		return emptyCancelRpc,err
-	}
-
-	if cancelable {
-		rpcCancel := RpcCancel{CallSeq:seq,Cli: rc}
-		return rpcCancel.CancelRpc,nil
-	}
-
-	return emptyCancelRpc,nil
-}

rpc/compressor.go

@@ -3,7 +3,7 @@ package rpc
 import (
 	"errors"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/util/bytespool"
+	"github.com/duanhf2012/origin/util/bytespool"
 	"github.com/pierrec/lz4/v4"
 	"runtime"
 )

rpc/dynamicdiscover.pb.go

@@ -0,0 +1,483 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.31.0
+// 	protoc        v4.24.0
+// source: proto/rpcproto/dynamicdiscover.proto
+
+package rpc
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type NodeInfo struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	NodeId            int32    `protobuf:"varint,1,opt,name=NodeId,proto3" json:"NodeId,omitempty"`
+	NodeName          string   `protobuf:"bytes,2,opt,name=NodeName,proto3" json:"NodeName,omitempty"`
+	ListenAddr        string   `protobuf:"bytes,3,opt,name=ListenAddr,proto3" json:"ListenAddr,omitempty"`
+	MaxRpcParamLen    uint32   `protobuf:"varint,4,opt,name=MaxRpcParamLen,proto3" json:"MaxRpcParamLen,omitempty"`
+	Private           bool     `protobuf:"varint,5,opt,name=Private,proto3" json:"Private,omitempty"`
+	Retire            bool     `protobuf:"varint,6,opt,name=Retire,proto3" json:"Retire,omitempty"`
+	PublicServiceList []string `protobuf:"bytes,7,rep,name=PublicServiceList,proto3" json:"PublicServiceList,omitempty"`
+}
+
+func (x *NodeInfo) Reset() {
+	*x = NodeInfo{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_rpcproto_dynamicdiscover_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *NodeInfo) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NodeInfo) ProtoMessage() {}
+
+func (x *NodeInfo) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_rpcproto_dynamicdiscover_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use NodeInfo.ProtoReflect.Descriptor instead.
+func (*NodeInfo) Descriptor() ([]byte, []int) {
+	return file_proto_rpcproto_dynamicdiscover_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *NodeInfo) GetNodeId() int32 {
+	if x != nil {
+		return x.NodeId
+	}
+	return 0
+}
+
+func (x *NodeInfo) GetNodeName() string {
+	if x != nil {
+		return x.NodeName
+	}
+	return ""
+}
+
+func (x *NodeInfo) GetListenAddr() string {
+	if x != nil {
+		return x.ListenAddr
+	}
+	return ""
+}
+
+func (x *NodeInfo) GetMaxRpcParamLen() uint32 {
+	if x != nil {
+		return x.MaxRpcParamLen
+	}
+	return 0
+}
+
+func (x *NodeInfo) GetPrivate() bool {
+	if x != nil {
+		return x.Private
+	}
+	return false
+}
+
+func (x *NodeInfo) GetRetire() bool {
+	if x != nil {
+		return x.Retire
+	}
+	return false
+}
+
+func (x *NodeInfo) GetPublicServiceList() []string {
+	if x != nil {
+		return x.PublicServiceList
+	}
+	return nil
+}
+
+// Client->Master
+type ServiceDiscoverReq struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	NodeInfo *NodeInfo `protobuf:"bytes,1,opt,name=nodeInfo,proto3" json:"nodeInfo,omitempty"`
+}
+
+func (x *ServiceDiscoverReq) Reset() {
+	*x = ServiceDiscoverReq{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_rpcproto_dynamicdiscover_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ServiceDiscoverReq) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ServiceDiscoverReq) ProtoMessage() {}
+
+func (x *ServiceDiscoverReq) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_rpcproto_dynamicdiscover_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ServiceDiscoverReq.ProtoReflect.Descriptor instead.
+func (*ServiceDiscoverReq) Descriptor() ([]byte, []int) {
+	return file_proto_rpcproto_dynamicdiscover_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *ServiceDiscoverReq) GetNodeInfo() *NodeInfo {
+	if x != nil {
+		return x.NodeInfo
+	}
+	return nil
+}
+
+// Master->Client
+type SubscribeDiscoverNotify struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	MasterNodeId int32       `protobuf:"varint,1,opt,name=MasterNodeId,proto3" json:"MasterNodeId,omitempty"`
+	IsFull       bool        `protobuf:"varint,2,opt,name=IsFull,proto3" json:"IsFull,omitempty"`
+	DelNodeId    int32       `protobuf:"varint,3,opt,name=DelNodeId,proto3" json:"DelNodeId,omitempty"`
+	NodeInfo     []*NodeInfo `protobuf:"bytes,4,rep,name=nodeInfo,proto3" json:"nodeInfo,omitempty"`
+}
+
+func (x *SubscribeDiscoverNotify) Reset() {
+	*x = SubscribeDiscoverNotify{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_rpcproto_dynamicdiscover_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SubscribeDiscoverNotify) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SubscribeDiscoverNotify) ProtoMessage() {}
+
+func (x *SubscribeDiscoverNotify) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_rpcproto_dynamicdiscover_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SubscribeDiscoverNotify.ProtoReflect.Descriptor instead.
+func (*SubscribeDiscoverNotify) Descriptor() ([]byte, []int) {
+	return file_proto_rpcproto_dynamicdiscover_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *SubscribeDiscoverNotify) GetMasterNodeId() int32 {
+	if x != nil {
+		return x.MasterNodeId
+	}
+	return 0
+}
+
+func (x *SubscribeDiscoverNotify) GetIsFull() bool {
+	if x != nil {
+		return x.IsFull
+	}
+	return false
+}
+
+func (x *SubscribeDiscoverNotify) GetDelNodeId() int32 {
+	if x != nil {
+		return x.DelNodeId
+	}
+	return 0
+}
+
+func (x *SubscribeDiscoverNotify) GetNodeInfo() []*NodeInfo {
+	if x != nil {
+		return x.NodeInfo
+	}
+	return nil
+}
+
+// Client->Master
+type NodeRetireReq struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	NodeInfo *NodeInfo `protobuf:"bytes,1,opt,name=nodeInfo,proto3" json:"nodeInfo,omitempty"`
+}
+
+func (x *NodeRetireReq) Reset() {
+	*x = NodeRetireReq{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_rpcproto_dynamicdiscover_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *NodeRetireReq) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NodeRetireReq) ProtoMessage() {}
+
+func (x *NodeRetireReq) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_rpcproto_dynamicdiscover_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use NodeRetireReq.ProtoReflect.Descriptor instead.
+func (*NodeRetireReq) Descriptor() ([]byte, []int) {
+	return file_proto_rpcproto_dynamicdiscover_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *NodeRetireReq) GetNodeInfo() *NodeInfo {
+	if x != nil {
+		return x.NodeInfo
+	}
+	return nil
+}
+
+// Master->Client
+type Empty struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *Empty) Reset() {
+	*x = Empty{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_rpcproto_dynamicdiscover_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Empty) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Empty) ProtoMessage() {}
+
+func (x *Empty) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_rpcproto_dynamicdiscover_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Empty.ProtoReflect.Descriptor instead.
+func (*Empty) Descriptor() ([]byte, []int) {
+	return file_proto_rpcproto_dynamicdiscover_proto_rawDescGZIP(), []int{4}
+}
+
+var File_proto_rpcproto_dynamicdiscover_proto protoreflect.FileDescriptor
+
+var file_proto_rpcproto_dynamicdiscover_proto_rawDesc = []byte{
+	0x0a, 0x24, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x72, 0x70, 0x63, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2f, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x72, 0x70, 0x63, 0x22, 0xe6, 0x01, 0x0a, 0x08,
+	0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x0a, 0x06, 0x4e, 0x6f, 0x64, 0x65,
+	0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64,
+	0x12, 0x1a, 0x0a, 0x08, 0x4e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x08, 0x4e, 0x6f, 0x64, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1e, 0x0a, 0x0a,
+	0x4c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x12, 0x26, 0x0a, 0x0e,
+	0x4d, 0x61, 0x78, 0x52, 0x70, 0x63, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x4c, 0x65, 0x6e, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x4d, 0x61, 0x78, 0x52, 0x70, 0x63, 0x50, 0x61, 0x72, 0x61,
+	0x6d, 0x4c, 0x65, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x18,
+	0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x12, 0x16,
+	0x0a, 0x06, 0x52, 0x65, 0x74, 0x69, 0x72, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06,
+	0x52, 0x65, 0x74, 0x69, 0x72, 0x65, 0x12, 0x2c, 0x0a, 0x11, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63,
+	0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x07, 0x20, 0x03, 0x28,
+	0x09, 0x52, 0x11, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
+	0x4c, 0x69, 0x73, 0x74, 0x22, 0x3f, 0x0a, 0x12, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44,
+	0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x52, 0x65, 0x71, 0x12, 0x29, 0x0a, 0x08, 0x6e, 0x6f,
+	0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x72,
+	0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f, 0x64,
+	0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x9e, 0x01, 0x0a, 0x17, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72,
+	0x69, 0x62, 0x65, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x4e, 0x6f, 0x74, 0x69, 0x66,
+	0x79, 0x12, 0x22, 0x0a, 0x0c, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x49,
+	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x4e,
+	0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x49, 0x73, 0x46, 0x75, 0x6c, 0x6c, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x49, 0x73, 0x46, 0x75, 0x6c, 0x6c, 0x12, 0x1c, 0x0a,
+	0x09, 0x44, 0x65, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x44, 0x65, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x29, 0x0a, 0x08, 0x6e,
+	0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0d, 0x2e,
+	0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f,
+	0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x3a, 0x0a, 0x0d, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65,
+	0x74, 0x69, 0x72, 0x65, 0x52, 0x65, 0x71, 0x12, 0x29, 0x0a, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x49,
+	0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x72, 0x70, 0x63, 0x2e,
+	0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e,
+	0x66, 0x6f, 0x22, 0x07, 0x0a, 0x05, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x42, 0x07, 0x5a, 0x05, 0x2e,
+	0x3b, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_proto_rpcproto_dynamicdiscover_proto_rawDescOnce sync.Once
+	file_proto_rpcproto_dynamicdiscover_proto_rawDescData = file_proto_rpcproto_dynamicdiscover_proto_rawDesc
+)
+
+func file_proto_rpcproto_dynamicdiscover_proto_rawDescGZIP() []byte {
+	file_proto_rpcproto_dynamicdiscover_proto_rawDescOnce.Do(func() {
+		file_proto_rpcproto_dynamicdiscover_proto_rawDescData = protoimpl.X.CompressGZIP(file_proto_rpcproto_dynamicdiscover_proto_rawDescData)
+	})
+	return file_proto_rpcproto_dynamicdiscover_proto_rawDescData
+}
+
+var file_proto_rpcproto_dynamicdiscover_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
+var file_proto_rpcproto_dynamicdiscover_proto_goTypes = []interface{}{
+	(*NodeInfo)(nil),                // 0: rpc.NodeInfo
+	(*ServiceDiscoverReq)(nil),      // 1: rpc.ServiceDiscoverReq
+	(*SubscribeDiscoverNotify)(nil), // 2: rpc.SubscribeDiscoverNotify
+	(*NodeRetireReq)(nil),           // 3: rpc.NodeRetireReq
+	(*Empty)(nil),                   // 4: rpc.Empty
+}
+var file_proto_rpcproto_dynamicdiscover_proto_depIdxs = []int32{
+	0, // 0: rpc.ServiceDiscoverReq.nodeInfo:type_name -> rpc.NodeInfo
+	0, // 1: rpc.SubscribeDiscoverNotify.nodeInfo:type_name -> rpc.NodeInfo
+	0, // 2: rpc.NodeRetireReq.nodeInfo:type_name -> rpc.NodeInfo
+	3, // [3:3] is the sub-list for method output_type
+	3, // [3:3] is the sub-list for method input_type
+	3, // [3:3] is the sub-list for extension type_name
+	3, // [3:3] is the sub-list for extension extendee
+	0, // [0:3] is the sub-list for field type_name
+}
+
+func init() { file_proto_rpcproto_dynamicdiscover_proto_init() }
+func file_proto_rpcproto_dynamicdiscover_proto_init() {
+	if File_proto_rpcproto_dynamicdiscover_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_proto_rpcproto_dynamicdiscover_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeInfo); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_rpcproto_dynamicdiscover_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ServiceDiscoverReq); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_rpcproto_dynamicdiscover_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*SubscribeDiscoverNotify); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_rpcproto_dynamicdiscover_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeRetireReq); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_rpcproto_dynamicdiscover_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Empty); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_proto_rpcproto_dynamicdiscover_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   5,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_proto_rpcproto_dynamicdiscover_proto_goTypes,
+		DependencyIndexes: file_proto_rpcproto_dynamicdiscover_proto_depIdxs,
+		MessageInfos:      file_proto_rpcproto_dynamicdiscover_proto_msgTypes,
+	}.Build()
+	File_proto_rpcproto_dynamicdiscover_proto = out.File
+	file_proto_rpcproto_dynamicdiscover_proto_rawDesc = nil
+	file_proto_rpcproto_dynamicdiscover_proto_goTypes = nil
+	file_proto_rpcproto_dynamicdiscover_proto_depIdxs = nil
+}

rpc/dynamicdiscover.proto

@@ -0,0 +1,36 @@
+syntax = "proto3";
+package rpc;
+option go_package = ".;rpc";
+
+message NodeInfo{
+    int32 NodeId = 1;
+    string NodeName = 2;
+    string ListenAddr  = 3;
+    uint32 MaxRpcParamLen = 4;
+    bool Private = 5;
+	bool Retire = 6;
+    repeated string PublicServiceList = 7;
+}
+
+//Client->Master
+message ServiceDiscoverReq{
+    NodeInfo nodeInfo = 1;
+}
+
+//Master->Client
+message SubscribeDiscoverNotify{
+    int32 MasterNodeId = 1;
+    bool IsFull = 2;
+    int32 DelNodeId    = 3;
+    repeated NodeInfo nodeInfo = 4;
+}
+
+
+//Client->Master
+message NodeRetireReq{
+    NodeInfo nodeInfo = 1;
+}
+
+//Master->Client
+message Empty{
+}

rpc/jsonprocessor.go

@@ -1,7 +1,7 @@
 package rpc
 
 import (
-	"github.com/duanhf2012/origin/v2/util/sync"
+	"github.com/duanhf2012/origin/util/sync"
 	jsoniter "github.com/json-iterator/go"
 	"reflect"
 )

rpc/lclient.go

@@ -2,8 +2,8 @@ package rpc
 
 import (
 	"errors"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/network"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/network"
 	"reflect"
 	"strings"
 	"sync/atomic"
@@ -37,7 +37,7 @@ func (lc *LClient) SetConn(conn *network.TCPConn){
 func (lc *LClient) Close(waitDone bool){
 }
 
-func (lc *LClient) Go(nodeId string,timeout time.Duration,rpcHandler IRpcHandler,noReply bool, serviceMethod string, args interface{}, reply interface{}) *Call {
+func (lc *LClient) Go(timeout time.Duration,rpcHandler IRpcHandler,noReply bool, serviceMethod string, args interface{}, reply interface{}) *Call {
 	pLocalRpcServer := rpcHandler.GetRpcServer()()
 	//判断是否是同一服务
 	findIndex := strings.Index(serviceMethod, ".")
@@ -70,7 +70,7 @@ func (lc *LClient) Go(nodeId string,timeout time.Duration,rpcHandler IRpcHandler
 }
 
 
-func (rc *LClient) RawGo(nodeId string,timeout time.Duration,rpcHandler IRpcHandler,processor IRpcProcessor, noReply bool, rpcMethodId uint32, serviceName string, rawArgs []byte, reply interface{}) *Call {
+func (rc *LClient) RawGo(timeout time.Duration,rpcHandler IRpcHandler,processor IRpcProcessor, noReply bool, rpcMethodId uint32, serviceName string, rawArgs []byte, reply interface{}) *Call {
 	pLocalRpcServer := rpcHandler.GetRpcServer()()
 	
 	//服务自我调用
@@ -92,7 +92,7 @@ func (rc *LClient) RawGo(nodeId string,timeout time.Duration,rpcHandler IRpcHand
 }
 
 
-func (lc *LClient) AsyncCall(nodeId string,timeout time.Duration,rpcHandler IRpcHandler, serviceMethod string, callback reflect.Value, args interface{}, reply interface{},cancelable bool)  (CancelRpc,error) {
+func (lc *LClient) AsyncCall(timeout time.Duration,rpcHandler IRpcHandler, serviceMethod string, callback reflect.Value, args interface{}, reply interface{},cancelable bool)  (CancelRpc,error) {
 	pLocalRpcServer := rpcHandler.GetRpcServer()()
 
 	//判断是否是同一服务
@@ -119,19 +119,17 @@ func (lc *LClient) AsyncCall(nodeId string,timeout time.Duration,rpcHandler IRpc
 	return calcelRpc,nil
 }
 
-func NewLClient(localNodeId string,callSet *CallSet) *Client{
+func NewLClient(nodeId int) *Client{
 	client := &Client{}
 	client.clientId = atomic.AddUint32(&clientSeq, 1)
-	client.targetNodeId = localNodeId
-	//client.maxCheckCallRpcCount = DefaultMaxCheckCallRpcCount
-	//client.callRpcTimeout = DefaultRpcTimeout
+	client.nodeId = nodeId
+	client.maxCheckCallRpcCount = DefaultMaxCheckCallRpcCount
+	client.callRpcTimeout = DefaultRpcTimeout
 
 	lClient := &LClient{}
 	lClient.selfClient = client
 	client.IRealClient = lClient
-	client.CallSet = callSet
+	client.InitPending()
+	go client.checkRpcCallTimeout()
 	return client
 }
-
-func (rc *LClient) Bind(server IServer){
-}

rpc/lserver.go

@@ -1,291 +0,0 @@
-package rpc
-import (
-	"errors"
-	"github.com/duanhf2012/origin/v2/log"
-	"reflect"
-	"time"
-	"strings"
-	"fmt"
-)
-
-
-type BaseServer struct {
-	localNodeId string
-	compressBytesLen int
-
-	rpcHandleFinder RpcHandleFinder
-	iServer IServer
-}
-
-func (ls *BaseServer) initBaseServer(compressBytesLen int,rpcHandleFinder RpcHandleFinder){
-	ls.compressBytesLen = compressBytesLen
-	ls.rpcHandleFinder = rpcHandleFinder
-}
-
-func (ls *BaseServer) myselfRpcHandlerGo(client *Client,handlerName string, serviceMethod string, args interface{},callBack reflect.Value, reply interface{}) error {
-	rpcHandler := ls.rpcHandleFinder.FindRpcHandler(handlerName)
-	if rpcHandler == nil {
-		err := errors.New("service method " + serviceMethod + " not config!")
-		log.Error("service method not config",log.String("serviceMethod",serviceMethod))
-		return err
-	}
-
-	return rpcHandler.CallMethod(client,serviceMethod, args,callBack, reply)
-}
-
-func (ls *BaseServer) selfNodeRpcHandlerGo(timeout time.Duration,processor IRpcProcessor, client *Client, noReply bool, handlerName string, rpcMethodId uint32, serviceMethod string, args interface{}, reply interface{}, rawArgs []byte) *Call {
-	pCall := MakeCall()
-	pCall.Seq = client.generateSeq()
-	pCall.TimeOut = timeout
-	pCall.ServiceMethod = serviceMethod
-
-	rpcHandler := ls.rpcHandleFinder.FindRpcHandler(handlerName)
-	if rpcHandler == nil {
-		err := errors.New("service method " + serviceMethod + " not config!")
-		log.Error("service method not config",log.String("serviceMethod",serviceMethod),log.ErrorAttr("error",err))
-		pCall.Seq = 0
-		pCall.DoError(err)
-
-		return pCall
-	}
-
-	var iParam interface{}
-	if processor == nil {
-		_, processor = GetProcessorType(args)
-	}
-
-	if args != nil {
-		var err error
-		iParam,err = processor.Clone(args)
-		if err != nil {
-			sErr := errors.New("RpcHandler " + handlerName + "."+serviceMethod+" deep copy inParam is error:" + err.Error())
-			log.Error("deep copy inParam is failed",log.String("handlerName",handlerName),log.String("serviceMethod",serviceMethod))
-			pCall.Seq = 0
-			pCall.DoError(sErr)
-
-			return pCall
-		}
-	}
-
-	req := MakeRpcRequest(processor, 0, rpcMethodId, serviceMethod, noReply, nil)
-	req.inParam = iParam
-	req.localReply = reply
-	if rawArgs != nil {
-		var err error
-		req.inParam, err = rpcHandler.UnmarshalInParam(processor, serviceMethod, rpcMethodId, rawArgs)
-		if err != nil {
-			log.Error("unmarshalInParam is failed",log.String("serviceMethod",serviceMethod),log.Uint32("rpcMethodId",rpcMethodId),log.ErrorAttr("error",err))
-			pCall.Seq = 0
-			pCall.DoError(err)
-			ReleaseRpcRequest(req)
-			return pCall
-		}
-	}
-
-	if noReply == false {
-		client.AddPending(pCall)
-		callSeq := pCall.Seq
-		req.requestHandle = func(Returns interface{}, Err RpcError) {
-			if reply != nil && Returns != reply && Returns != nil {
-				byteReturns, err := req.rpcProcessor.Marshal(Returns)
-				if err != nil {
-					Err = ConvertError(err)
-					log.Error("returns data cannot be marshal",log.Uint64("seq",callSeq),log.ErrorAttr("error",err))
-				}else{
-					err = req.rpcProcessor.Unmarshal(byteReturns, reply)
-					if err != nil {
-						Err = ConvertError(err)
-						log.Error("returns data cannot be Unmarshal",log.Uint64("seq",callSeq),log.ErrorAttr("error",err))
-					}
-				}
-			}
-
-			ReleaseRpcRequest(req)
-			v := client.RemovePending(callSeq)
-			if v == nil {
-				log.Error("rpcClient cannot find seq",log.Uint64("seq",callSeq))
-				return
-			}
-
-			if len(Err) == 0 {
-				v.Err = nil
-				v.DoOK()
-			} else {
-				log.Error(Err.Error())
-				v.DoError(Err)
-			}
-		}
-	}
-
-	err := rpcHandler.PushRpcRequest(req)
-	if err != nil {
-		log.Error(err.Error())
-		pCall.DoError(err)
-		ReleaseRpcRequest(req)
-	}
-
-	return pCall
-}
-
-func (server *BaseServer) selfNodeRpcHandlerAsyncGo(timeout time.Duration,client *Client, callerRpcHandler IRpcHandler, noReply bool, handlerName string, serviceMethod string, args interface{}, reply interface{}, callback reflect.Value,cancelable bool) (CancelRpc,error)  {
-	rpcHandler := server.rpcHandleFinder.FindRpcHandler(handlerName)
-	if rpcHandler == nil {
-		err := errors.New("service method " + serviceMethod + " not config!")
-		log.Error(err.Error())
-		return emptyCancelRpc,err
-	}
-
-	_, processor := GetProcessorType(args)
-	iParam,err := processor.Clone(args)
-	if err != nil {
-		errM := errors.New("RpcHandler " + handlerName + "."+serviceMethod+" deep copy inParam is error:" + err.Error())
-		log.Error(errM.Error())
-		return emptyCancelRpc,errM
-	}
-
-	req := MakeRpcRequest(processor, 0, 0, serviceMethod, noReply, nil)
-	req.inParam = iParam
-	req.localReply = reply
-
-	cancelRpc := emptyCancelRpc
-	var callSeq uint64
-	if noReply == false {
-		callSeq = client.generateSeq()
-		pCall := MakeCall()
-		pCall.Seq = callSeq
-		pCall.rpcHandler = callerRpcHandler
-		pCall.callback = &callback
-		pCall.Reply = reply
-		pCall.ServiceMethod = serviceMethod
-		pCall.TimeOut = timeout
-		client.AddPending(pCall)
-		rpcCancel :=  RpcCancel{CallSeq: callSeq,Cli: client}
-		cancelRpc = rpcCancel.CancelRpc
-
-		req.requestHandle = func(Returns interface{}, Err RpcError) {
-			v := client.RemovePending(callSeq)
-			if v == nil {
-				ReleaseRpcRequest(req)
-				return
-			}
-			if len(Err) == 0 {
-				v.Err = nil
-			} else {
-				v.Err = Err
-			}
-
-			if Returns != nil {
-				v.Reply = Returns
-			}
-			v.rpcHandler.PushRpcResponse(v)
-			ReleaseRpcRequest(req)
-		}
-	}
-
-	err = rpcHandler.PushRpcRequest(req)
-	if err != nil {
-		ReleaseRpcRequest(req)
-		if callSeq > 0 {
-			client.RemovePending(callSeq)
-		}
-		return emptyCancelRpc,err
-	}
-
-	return cancelRpc,nil
-}
-
-func (bs *BaseServer) processRpcRequest(data []byte,connTag string,wrResponse writeResponse) error{
-	bCompress := (data[0]>>7) > 0
-	processor := GetProcessor(data[0]&0x7f)
-	if processor == nil {
-		return errors.New("cannot find processor")
-	}
-
-	//解析head
-	var compressBuff []byte
-	byteData := data[1:]
-	if bCompress == true {
-		var unCompressErr error
-
-		compressBuff,unCompressErr = compressor.UncompressBlock(byteData)
-		if unCompressErr!= nil {
-			return errors.New("UncompressBlock failed")
-		}
-
-		byteData = compressBuff
-	}
-
-	req := MakeRpcRequest(processor, 0, 0, "", false, nil)
-	err := processor.Unmarshal(byteData, req.RpcRequestData)
-	if cap(compressBuff) > 0 {
-		compressor.UnCompressBufferCollection(compressBuff)
-	}
-
-	if err != nil {
-		if req.RpcRequestData.GetSeq() > 0 {
-			rpcError := RpcError(err.Error())
-			if req.RpcRequestData.IsNoReply() == false {
-				wrResponse(processor,connTag, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), nil, rpcError)
-			}
-		}
-
-		ReleaseRpcRequest(req)
-		return err
-	}
-
-	//交给程序处理
-	serviceMethod := strings.Split(req.RpcRequestData.GetServiceMethod(), ".")
-	if len(serviceMethod) < 1 {
-		rpcError := RpcError("rpc request req.ServiceMethod is error")
-		if req.RpcRequestData.IsNoReply() == false {
-			wrResponse(processor,connTag, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), nil, rpcError)
-		}
-		ReleaseRpcRequest(req)
-		log.Error("rpc request req.ServiceMethod is error")
-		return nil
-	}
-
-	rpcHandler := bs.rpcHandleFinder.FindRpcHandler(serviceMethod[0])
-	if rpcHandler == nil {
-		rpcError := RpcError(fmt.Sprintf("service method %s not config!", req.RpcRequestData.GetServiceMethod()))
-		if req.RpcRequestData.IsNoReply() == false {
-			wrResponse(processor,connTag, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), nil, rpcError)
-		}
-		log.Error("serviceMethod not config",log.String("serviceMethod",req.RpcRequestData.GetServiceMethod()))
-		ReleaseRpcRequest(req)
-		return nil
-	}
-
-	if req.RpcRequestData.IsNoReply() == false {
-		req.requestHandle = func(Returns interface{}, Err RpcError) {
-			wrResponse(processor,connTag, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), Returns, Err)
-			ReleaseRpcRequest(req)
-		}
-	}
-
-	req.inParam, err = rpcHandler.UnmarshalInParam(req.rpcProcessor, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetRpcMethodId(), req.RpcRequestData.GetInParam())
-	if err != nil {
-		rErr := "Call Rpc " + req.RpcRequestData.GetServiceMethod() + " Param error " + err.Error()
-		log.Error("call rpc param error",log.String("serviceMethod",req.RpcRequestData.GetServiceMethod()),log.ErrorAttr("error",err))
-		if req.requestHandle != nil {
-			req.requestHandle(nil, RpcError(rErr))
-		} else {
-			ReleaseRpcRequest(req)
-		}
-
-		return nil
-	}
-
-	err = rpcHandler.PushRpcRequest(req)
-	if err != nil {
-		rpcError := RpcError(err.Error())
-
-		if req.RpcRequestData.IsNoReply() {
-			wrResponse(processor, connTag,req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), nil, rpcError)
-		}
-
-		ReleaseRpcRequest(req)
-	}
-
-	return nil
-}

rpc/natsclient.go

@@ -1,90 +0,0 @@
-package rpc
-import (
-	"github.com/duanhf2012/origin/v2/network"
-	"reflect"
-	"time"
-	"github.com/nats-io/nats.go"
-	"github.com/duanhf2012/origin/v2/log"
-)
-
-//跨结点连接的Client
-type NatsClient struct {
-	localNodeId string
-	notifyEventFun NotifyEventFun
-	
-	natsConn *nats.Conn
-	client *Client
-}
-
-func (nc *NatsClient) Start(natsConn *nats.Conn) error{
-	nc.natsConn = natsConn
-	_,err := nc.natsConn.QueueSubscribe("oc."+nc.localNodeId, "oc",nc.onSubscribe)
-
-	return err
-}
-
-func (nc *NatsClient) onSubscribe(msg *nats.Msg){
-	//处理消息
-	nc.client.processRpcResponse(msg.Data)
-}
-
-func (nc *NatsClient) SetConn(conn *network.TCPConn){
-}
-
-func (nc *NatsClient) Close(waitDone bool){
-}
-
-func (nc *NatsClient) Run(){
-}
-
-func (nc *NatsClient)  OnClose(){
-}
-
-func (rc *NatsClient) Bind(server IServer){
-	s := server.(*NatsServer)
-	rc.natsConn = s.natsConn
-}
-
-func (rc *NatsClient) Go(nodeId string,timeout time.Duration,rpcHandler IRpcHandler,noReply bool, serviceMethod string, args interface{}, reply interface{}) *Call {
-	_, processor := GetProcessorType(args)
-	InParam, err := processor.Marshal(args)
-	if err != nil {
-		log.Error("Marshal is fail",log.ErrorAttr("error",err))
-		call := MakeCall()
-		call.DoError(err)
-		return call
-	}
-
-	return rc.client.rawGo(nodeId,rc,timeout,rpcHandler,processor, noReply, 0, serviceMethod, InParam, reply)
-}
-
-func (rc *NatsClient) RawGo(nodeId string,timeout time.Duration,rpcHandler IRpcHandler,processor IRpcProcessor, noReply bool, rpcMethodId uint32, serviceMethod string, rawArgs []byte, reply interface{}) *Call {
-	return rc.client.rawGo(nodeId,rc,timeout,rpcHandler,processor, noReply, rpcMethodId, serviceMethod, rawArgs, reply)
-}
-
-func (rc *NatsClient) AsyncCall(nodeId string,timeout time.Duration,rpcHandler IRpcHandler, serviceMethod string, callback reflect.Value, args interface{}, replyParam interface{},cancelable bool)  (CancelRpc,error) {
-	cancelRpc,err := rc.client.asyncCall(nodeId,rc,timeout,rpcHandler, serviceMethod, callback, args, replyParam,cancelable)
-	if err != nil {
-		callback.Call([]reflect.Value{reflect.ValueOf(replyParam), reflect.ValueOf(err)})
-	}
-
-	return cancelRpc,nil
-}
-
-func (rc *NatsClient) WriteMsg (nodeId string,args ...[]byte) error{
-	buff := make([]byte,0,4096)
-	for _,ar := range args {
-		buff = append(buff,ar...)
-	}
-
-	var msg nats.Msg
-	msg.Subject = "os."+nodeId
-	msg.Data = buff
-	msg.Header = nats.Header{}
-	msg.Header.Set("fnode",rc.localNodeId)
-	return rc.natsConn.PublishMsg(&msg)
-}
-
-func (rc *NatsClient) IsConnected() bool{
-	return rc.natsConn!=nil && rc.natsConn.Status() == nats.CONNECTED
-}

rpc/natsserver.go

@@ -1,127 +0,0 @@
-package rpc
-
-import (
-	"github.com/nats-io/nats.go"
-	"github.com/duanhf2012/origin/v2/log"
-	"time"
-)
-
-type NatsServer struct {
-	BaseServer
-	natsUrl string
-	
-	natsConn *nats.Conn
-	NoRandomize bool
-
-	nodeSubTopic string
-	compressBytesLen int
-	notifyEventFun NotifyEventFun
-}
-
-const reconnectWait = 3*time.Second
-func (ns *NatsServer) Start() error{
-	var err error
-	var options []nats.Option
-
-	options = append(options,nats.DisconnectErrHandler(func(nc *nats.Conn, err error) {
-		log.Error("nats is disconnected",log.String("connUrl",nc.ConnectedUrl()))
-		ns.notifyEventFun(&NatsConnEvent{IsConnect:false})
-	}))
-
-	options = append(options,nats.ConnectHandler(func(nc *nats.Conn) {
-		log.Info("nats is connected",log.String("connUrl",nc.ConnectedUrl()))
-		ns.notifyEventFun(&NatsConnEvent{IsConnect:true})
-		//log.Error("nats is connect",log.String("connUrl",nc.ConnectedUrl()))
-	}))
-
-	options = append(options,nats.ReconnectHandler(func(nc *nats.Conn) {
-		ns.notifyEventFun(&NatsConnEvent{IsConnect:true})
-		log.Info("nats is reconnected",log.String("connUrl",nc.ConnectedUrl()))
-	}))
-
-	options = append(options,nats.MaxReconnects(-1))
-	options = append(options,nats.ReconnectWait(reconnectWait))
-
-	if ns.NoRandomize {
-		options = append(options,nats.DontRandomize())
-	}
-
-	ns.natsConn,err = nats.Connect(ns.natsUrl,options...)
-	if err != nil {
-		log.Error("Connect to nats fail",log.String("natsUrl",ns.natsUrl),log.ErrorAttr("err",err))
-		return err
-	}
-
-	//开始订阅
-	_,err = ns.natsConn.QueueSubscribe(ns.nodeSubTopic,"os", func(msg *nats.Msg) {
-		ns.processRpcRequest(msg.Data,msg.Header.Get("fnode"),ns.WriteResponse)
-	})
-
-	return err
-}
-
-func (ns *NatsServer) WriteResponse(processor IRpcProcessor, nodeId string,serviceMethod string, seq uint64, reply interface{}, rpcError RpcError){
-	var mReply []byte
-	var err error
-
-	if reply != nil {
-		mReply, err = processor.Marshal(reply)
-		if err != nil {
-			rpcError = ConvertError(err)
-		}
-	}
-
-	var rpcResponse RpcResponse
-	rpcResponse.RpcResponseData = processor.MakeRpcResponse(seq, rpcError, mReply)
-	bytes, err := processor.Marshal(rpcResponse.RpcResponseData)
-	defer processor.ReleaseRpcResponse(rpcResponse.RpcResponseData)
-
-	if err != nil {
-		log.Error("mashal RpcResponseData failed",log.String("serviceMethod",serviceMethod),log.ErrorAttr("error",err))
-		return
-	}
-
-	var compressBuff[]byte
-	bCompress := uint8(0)
-	if ns.compressBytesLen >0 && len(bytes) >= ns.compressBytesLen {
-		compressBuff,err = compressor.CompressBlock(bytes)
-		if err != nil {
-			log.Error("CompressBlock failed",log.String("serviceMethod",serviceMethod),log.ErrorAttr("error",err))
-			return
-		}
-		if len(compressBuff) < len(bytes) {
-			bytes = compressBuff
-			bCompress = 1<<7
-		}
-	}
-
-	sendData := make([]byte,0,4096)
-	byteTypeAndCompress := []byte{uint8(processor.GetProcessorType())|bCompress}
-	sendData = append(sendData,byteTypeAndCompress...)
-	sendData = append(sendData,bytes...)
-	err = ns.natsConn.PublishMsg(&nats.Msg{Subject: "oc."+nodeId, Data: sendData})
-
-	if cap(compressBuff) >0 {
-		compressor.CompressBufferCollection(compressBuff)
-	}
-
-	if err != nil {
-		log.Error("WriteMsg error,Rpc return is fail",log.String("nodeId",nodeId),log.String("serviceMethod",serviceMethod),log.ErrorAttr("error",err))
-	}
-}
-
-func (ns *NatsServer) Stop(){
-	if ns.natsConn != nil {
-		ns.natsConn.Close()
-	}
-}
-
-func (ns *NatsServer) initServer(natsUrl string, noRandomize bool,localNodeId string,compressBytesLen int,rpcHandleFinder RpcHandleFinder,notifyEventFun NotifyEventFun){
-	ns.natsUrl = natsUrl
-	ns.NoRandomize = noRandomize
-	ns.localNodeId = localNodeId
-	ns.compressBytesLen = compressBytesLen
-	ns.notifyEventFun = notifyEventFun
-	ns.initBaseServer(compressBytesLen,rpcHandleFinder)
-	ns.nodeSubTopic = "os."+localNodeId //服务器
-}

rpc/origindiscover.pb.go

@@ -1,662 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.31.0
-// 	protoc        v4.24.0
-// source: rpcproto/origindiscover.proto
-
-package rpc
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
-)
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
-
-type NodeInfo struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	NodeId            string   `protobuf:"bytes,1,opt,name=NodeId,proto3" json:"NodeId,omitempty"`
-	ListenAddr        string   `protobuf:"bytes,2,opt,name=ListenAddr,proto3" json:"ListenAddr,omitempty"`
-	MaxRpcParamLen    uint32   `protobuf:"varint,3,opt,name=MaxRpcParamLen,proto3" json:"MaxRpcParamLen,omitempty"`
-	Private           bool     `protobuf:"varint,4,opt,name=Private,proto3" json:"Private,omitempty"`
-	Retire            bool     `protobuf:"varint,5,opt,name=Retire,proto3" json:"Retire,omitempty"`
-	PublicServiceList []string `protobuf:"bytes,6,rep,name=PublicServiceList,proto3" json:"PublicServiceList,omitempty"`
-}
-
-func (x *NodeInfo) Reset() {
-	*x = NodeInfo{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_rpcproto_origindiscover_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *NodeInfo) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*NodeInfo) ProtoMessage() {}
-
-func (x *NodeInfo) ProtoReflect() protoreflect.Message {
-	mi := &file_rpcproto_origindiscover_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use NodeInfo.ProtoReflect.Descriptor instead.
-func (*NodeInfo) Descriptor() ([]byte, []int) {
-	return file_rpcproto_origindiscover_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *NodeInfo) GetNodeId() string {
-	if x != nil {
-		return x.NodeId
-	}
-	return ""
-}
-
-func (x *NodeInfo) GetListenAddr() string {
-	if x != nil {
-		return x.ListenAddr
-	}
-	return ""
-}
-
-func (x *NodeInfo) GetMaxRpcParamLen() uint32 {
-	if x != nil {
-		return x.MaxRpcParamLen
-	}
-	return 0
-}
-
-func (x *NodeInfo) GetPrivate() bool {
-	if x != nil {
-		return x.Private
-	}
-	return false
-}
-
-func (x *NodeInfo) GetRetire() bool {
-	if x != nil {
-		return x.Retire
-	}
-	return false
-}
-
-func (x *NodeInfo) GetPublicServiceList() []string {
-	if x != nil {
-		return x.PublicServiceList
-	}
-	return nil
-}
-
-// Client->Master
-type RegServiceDiscoverReq struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	NodeInfo *NodeInfo `protobuf:"bytes,1,opt,name=nodeInfo,proto3" json:"nodeInfo,omitempty"`
-}
-
-func (x *RegServiceDiscoverReq) Reset() {
-	*x = RegServiceDiscoverReq{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_rpcproto_origindiscover_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *RegServiceDiscoverReq) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*RegServiceDiscoverReq) ProtoMessage() {}
-
-func (x *RegServiceDiscoverReq) ProtoReflect() protoreflect.Message {
-	mi := &file_rpcproto_origindiscover_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use RegServiceDiscoverReq.ProtoReflect.Descriptor instead.
-func (*RegServiceDiscoverReq) Descriptor() ([]byte, []int) {
-	return file_rpcproto_origindiscover_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *RegServiceDiscoverReq) GetNodeInfo() *NodeInfo {
-	if x != nil {
-		return x.NodeInfo
-	}
-	return nil
-}
-
-// Master->Client
-type SubscribeDiscoverNotify struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	MasterNodeId string      `protobuf:"bytes,1,opt,name=MasterNodeId,proto3" json:"MasterNodeId,omitempty"`
-	IsFull       bool        `protobuf:"varint,2,opt,name=IsFull,proto3" json:"IsFull,omitempty"`
-	DelNodeId    string      `protobuf:"bytes,3,opt,name=DelNodeId,proto3" json:"DelNodeId,omitempty"`
-	NodeInfo     []*NodeInfo `protobuf:"bytes,4,rep,name=nodeInfo,proto3" json:"nodeInfo,omitempty"`
-}
-
-func (x *SubscribeDiscoverNotify) Reset() {
-	*x = SubscribeDiscoverNotify{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_rpcproto_origindiscover_proto_msgTypes[2]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *SubscribeDiscoverNotify) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*SubscribeDiscoverNotify) ProtoMessage() {}
-
-func (x *SubscribeDiscoverNotify) ProtoReflect() protoreflect.Message {
-	mi := &file_rpcproto_origindiscover_proto_msgTypes[2]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use SubscribeDiscoverNotify.ProtoReflect.Descriptor instead.
-func (*SubscribeDiscoverNotify) Descriptor() ([]byte, []int) {
-	return file_rpcproto_origindiscover_proto_rawDescGZIP(), []int{2}
-}
-
-func (x *SubscribeDiscoverNotify) GetMasterNodeId() string {
-	if x != nil {
-		return x.MasterNodeId
-	}
-	return ""
-}
-
-func (x *SubscribeDiscoverNotify) GetIsFull() bool {
-	if x != nil {
-		return x.IsFull
-	}
-	return false
-}
-
-func (x *SubscribeDiscoverNotify) GetDelNodeId() string {
-	if x != nil {
-		return x.DelNodeId
-	}
-	return ""
-}
-
-func (x *SubscribeDiscoverNotify) GetNodeInfo() []*NodeInfo {
-	if x != nil {
-		return x.NodeInfo
-	}
-	return nil
-}
-
-// Client->Master
-type NodeRetireReq struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	NodeInfo *NodeInfo `protobuf:"bytes,1,opt,name=nodeInfo,proto3" json:"nodeInfo,omitempty"`
-}
-
-func (x *NodeRetireReq) Reset() {
-	*x = NodeRetireReq{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_rpcproto_origindiscover_proto_msgTypes[3]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *NodeRetireReq) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*NodeRetireReq) ProtoMessage() {}
-
-func (x *NodeRetireReq) ProtoReflect() protoreflect.Message {
-	mi := &file_rpcproto_origindiscover_proto_msgTypes[3]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use NodeRetireReq.ProtoReflect.Descriptor instead.
-func (*NodeRetireReq) Descriptor() ([]byte, []int) {
-	return file_rpcproto_origindiscover_proto_rawDescGZIP(), []int{3}
-}
-
-func (x *NodeRetireReq) GetNodeInfo() *NodeInfo {
-	if x != nil {
-		return x.NodeInfo
-	}
-	return nil
-}
-
-// Master->Client
-type Empty struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-}
-
-func (x *Empty) Reset() {
-	*x = Empty{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_rpcproto_origindiscover_proto_msgTypes[4]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Empty) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Empty) ProtoMessage() {}
-
-func (x *Empty) ProtoReflect() protoreflect.Message {
-	mi := &file_rpcproto_origindiscover_proto_msgTypes[4]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Empty.ProtoReflect.Descriptor instead.
-func (*Empty) Descriptor() ([]byte, []int) {
-	return file_rpcproto_origindiscover_proto_rawDescGZIP(), []int{4}
-}
-
-// Client->Master
-type Ping struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	NodeId string `protobuf:"bytes,1,opt,name=NodeId,proto3" json:"NodeId,omitempty"`
-}
-
-func (x *Ping) Reset() {
-	*x = Ping{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_rpcproto_origindiscover_proto_msgTypes[5]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Ping) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Ping) ProtoMessage() {}
-
-func (x *Ping) ProtoReflect() protoreflect.Message {
-	mi := &file_rpcproto_origindiscover_proto_msgTypes[5]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Ping.ProtoReflect.Descriptor instead.
-func (*Ping) Descriptor() ([]byte, []int) {
-	return file_rpcproto_origindiscover_proto_rawDescGZIP(), []int{5}
-}
-
-func (x *Ping) GetNodeId() string {
-	if x != nil {
-		return x.NodeId
-	}
-	return ""
-}
-
-// Master->Client
-type Pong struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"`
-}
-
-func (x *Pong) Reset() {
-	*x = Pong{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_rpcproto_origindiscover_proto_msgTypes[6]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Pong) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Pong) ProtoMessage() {}
-
-func (x *Pong) ProtoReflect() protoreflect.Message {
-	mi := &file_rpcproto_origindiscover_proto_msgTypes[6]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Pong.ProtoReflect.Descriptor instead.
-func (*Pong) Descriptor() ([]byte, []int) {
-	return file_rpcproto_origindiscover_proto_rawDescGZIP(), []int{6}
-}
-
-func (x *Pong) GetOk() bool {
-	if x != nil {
-		return x.Ok
-	}
-	return false
-}
-
-type UnRegServiceDiscoverReq struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	NodeId string `protobuf:"bytes,1,opt,name=NodeId,proto3" json:"NodeId,omitempty"`
-}
-
-func (x *UnRegServiceDiscoverReq) Reset() {
-	*x = UnRegServiceDiscoverReq{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_rpcproto_origindiscover_proto_msgTypes[7]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *UnRegServiceDiscoverReq) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*UnRegServiceDiscoverReq) ProtoMessage() {}
-
-func (x *UnRegServiceDiscoverReq) ProtoReflect() protoreflect.Message {
-	mi := &file_rpcproto_origindiscover_proto_msgTypes[7]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use UnRegServiceDiscoverReq.ProtoReflect.Descriptor instead.
-func (*UnRegServiceDiscoverReq) Descriptor() ([]byte, []int) {
-	return file_rpcproto_origindiscover_proto_rawDescGZIP(), []int{7}
-}
-
-func (x *UnRegServiceDiscoverReq) GetNodeId() string {
-	if x != nil {
-		return x.NodeId
-	}
-	return ""
-}
-
-var File_rpcproto_origindiscover_proto protoreflect.FileDescriptor
-
-var file_rpcproto_origindiscover_proto_rawDesc = []byte{
-	0x0a, 0x1d, 0x72, 0x70, 0x63, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x6f, 0x72, 0x69, 0x67, 0x69,
-	0x6e, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
-	0x03, 0x72, 0x70, 0x63, 0x22, 0xca, 0x01, 0x0a, 0x08, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66,
-	0x6f, 0x12, 0x16, 0x0a, 0x06, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x06, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x4c, 0x69, 0x73,
-	0x74, 0x65, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x4c,
-	0x69, 0x73, 0x74, 0x65, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x12, 0x26, 0x0a, 0x0e, 0x4d, 0x61, 0x78,
-	0x52, 0x70, 0x63, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x4c, 0x65, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28,
-	0x0d, 0x52, 0x0e, 0x4d, 0x61, 0x78, 0x52, 0x70, 0x63, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x4c, 0x65,
-	0x6e, 0x12, 0x18, 0x0a, 0x07, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01,
-	0x28, 0x08, 0x52, 0x07, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x52,
-	0x65, 0x74, 0x69, 0x72, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x52, 0x65, 0x74,
-	0x69, 0x72, 0x65, 0x12, 0x2c, 0x0a, 0x11, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x53, 0x65, 0x72,
-	0x76, 0x69, 0x63, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x11,
-	0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4c, 0x69, 0x73,
-	0x74, 0x22, 0x42, 0x0a, 0x15, 0x52, 0x65, 0x67, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44,
-	0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x52, 0x65, 0x71, 0x12, 0x29, 0x0a, 0x08, 0x6e, 0x6f,
-	0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x72,
-	0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f, 0x64,
-	0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x9e, 0x01, 0x0a, 0x17, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72,
-	0x69, 0x62, 0x65, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x4e, 0x6f, 0x74, 0x69, 0x66,
-	0x79, 0x12, 0x22, 0x0a, 0x0c, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x49,
-	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x4e,
-	0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x49, 0x73, 0x46, 0x75, 0x6c, 0x6c, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x49, 0x73, 0x46, 0x75, 0x6c, 0x6c, 0x12, 0x1c, 0x0a,
-	0x09, 0x44, 0x65, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x09, 0x44, 0x65, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x29, 0x0a, 0x08, 0x6e,
-	0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0d, 0x2e,
-	0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f,
-	0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x3a, 0x0a, 0x0d, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65,
-	0x74, 0x69, 0x72, 0x65, 0x52, 0x65, 0x71, 0x12, 0x29, 0x0a, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x49,
-	0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x72, 0x70, 0x63, 0x2e,
-	0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e,
-	0x66, 0x6f, 0x22, 0x07, 0x0a, 0x05, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x1e, 0x0a, 0x04, 0x50,
-	0x69, 0x6e, 0x67, 0x12, 0x16, 0x0a, 0x06, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x06, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x22, 0x16, 0x0a, 0x04, 0x50,
-	0x6f, 0x6e, 0x67, 0x12, 0x0e, 0x0a, 0x02, 0x6f, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52,
-	0x02, 0x6f, 0x6b, 0x22, 0x31, 0x0a, 0x17, 0x55, 0x6e, 0x52, 0x65, 0x67, 0x53, 0x65, 0x72, 0x76,
-	0x69, 0x63, 0x65, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x52, 0x65, 0x71, 0x12, 0x16,
-	0x0a, 0x06, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06,
-	0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x42, 0x07, 0x5a, 0x05, 0x2e, 0x3b, 0x72, 0x70, 0x63, 0x62,
-	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_rpcproto_origindiscover_proto_rawDescOnce sync.Once
-	file_rpcproto_origindiscover_proto_rawDescData = file_rpcproto_origindiscover_proto_rawDesc
-)
-
-func file_rpcproto_origindiscover_proto_rawDescGZIP() []byte {
-	file_rpcproto_origindiscover_proto_rawDescOnce.Do(func() {
-		file_rpcproto_origindiscover_proto_rawDescData = protoimpl.X.CompressGZIP(file_rpcproto_origindiscover_proto_rawDescData)
-	})
-	return file_rpcproto_origindiscover_proto_rawDescData
-}
-
-var file_rpcproto_origindiscover_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
-var file_rpcproto_origindiscover_proto_goTypes = []interface{}{
-	(*NodeInfo)(nil),                // 0: rpc.NodeInfo
-	(*RegServiceDiscoverReq)(nil),   // 1: rpc.RegServiceDiscoverReq
-	(*SubscribeDiscoverNotify)(nil), // 2: rpc.SubscribeDiscoverNotify
-	(*NodeRetireReq)(nil),           // 3: rpc.NodeRetireReq
-	(*Empty)(nil),                   // 4: rpc.Empty
-	(*Ping)(nil),                    // 5: rpc.Ping
-	(*Pong)(nil),                    // 6: rpc.Pong
-	(*UnRegServiceDiscoverReq)(nil), // 7: rpc.UnRegServiceDiscoverReq
-}
-var file_rpcproto_origindiscover_proto_depIdxs = []int32{
-	0, // 0: rpc.RegServiceDiscoverReq.nodeInfo:type_name -> rpc.NodeInfo
-	0, // 1: rpc.SubscribeDiscoverNotify.nodeInfo:type_name -> rpc.NodeInfo
-	0, // 2: rpc.NodeRetireReq.nodeInfo:type_name -> rpc.NodeInfo
-	3, // [3:3] is the sub-list for method output_type
-	3, // [3:3] is the sub-list for method input_type
-	3, // [3:3] is the sub-list for extension type_name
-	3, // [3:3] is the sub-list for extension extendee
-	0, // [0:3] is the sub-list for field type_name
-}
-
-func init() { file_rpcproto_origindiscover_proto_init() }
-func file_rpcproto_origindiscover_proto_init() {
-	if File_rpcproto_origindiscover_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_rpcproto_origindiscover_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*NodeInfo); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_rpcproto_origindiscover_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*RegServiceDiscoverReq); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_rpcproto_origindiscover_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SubscribeDiscoverNotify); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_rpcproto_origindiscover_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*NodeRetireReq); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_rpcproto_origindiscover_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Empty); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_rpcproto_origindiscover_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Ping); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_rpcproto_origindiscover_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Pong); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_rpcproto_origindiscover_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*UnRegServiceDiscoverReq); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_rpcproto_origindiscover_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   8,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_rpcproto_origindiscover_proto_goTypes,
-		DependencyIndexes: file_rpcproto_origindiscover_proto_depIdxs,
-		MessageInfos:      file_rpcproto_origindiscover_proto_msgTypes,
-	}.Build()
-	File_rpcproto_origindiscover_proto = out.File
-	file_rpcproto_origindiscover_proto_rawDesc = nil
-	file_rpcproto_origindiscover_proto_goTypes = nil
-	file_rpcproto_origindiscover_proto_depIdxs = nil
-}

rpc/origindiscover.proto

@@ -1,49 +0,0 @@
-syntax = "proto3";
-package rpc;
-option go_package = ".;rpc";
-
-message NodeInfo{
-    string NodeId = 1;
-    string ListenAddr  = 2;
-    uint32 MaxRpcParamLen = 3;
-    bool Private = 4;
-	bool Retire = 5;
-    repeated string PublicServiceList = 6;
-}
-
-//Client->Master
-message RegServiceDiscoverReq{
-    NodeInfo nodeInfo = 1;
-}
-
-//Master->Client
-message SubscribeDiscoverNotify{
-    string MasterNodeId = 1;
-    bool IsFull = 2;
-    string DelNodeId    = 3;
-    repeated NodeInfo nodeInfo = 4;
-}
-
-
-//Client->Master
-message NodeRetireReq{
-    NodeInfo nodeInfo = 1;
-}
-
-//Master->Client
-message Empty{
-}
-
-//Client->Master
-message Ping{
-    string NodeId = 1;
-}
-
-//Master->Client
-message Pong{
-    bool ok = 1;
-}
-
-message UnRegServiceDiscoverReq{
-    string NodeId = 1;
-}

rpc/pbprocessor.go

@@ -1,7 +1,7 @@
 package rpc
 
 import (
-	"github.com/duanhf2012/origin/v2/util/sync"
+	"github.com/duanhf2012/origin/util/sync"
 	"google.golang.org/protobuf/proto"
 	"fmt"
 )

rpc/rclient.go

@@ -1,9 +1,10 @@
 package rpc
 
 import (
+	"errors"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/network"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/network"
 	"math"
 	"reflect"
 	"runtime"
@@ -13,11 +14,11 @@ import (
 
 //跨结点连接的Client
 type RClient struct {
+	compressBytesLen int
 	selfClient *Client
 	network.TCPClient
 	conn *network.TCPConn
-
-	notifyEventFun NotifyEventFun
+	TriggerRpcConnEvent
 }
 
 func (rc *RClient) IsConnected() bool {
@@ -41,11 +42,7 @@ func (rc *RClient) SetConn(conn *network.TCPConn){
 	rc.Unlock()
 }
 
-func (rc *RClient) WriteMsg (nodeId string,args ...[]byte) error{
-	return rc.conn.WriteMsg(args...)
-}
-
-func (rc *RClient) Go(nodeId string,timeout time.Duration,rpcHandler IRpcHandler,noReply bool, serviceMethod string, args interface{}, reply interface{}) *Call {
+func (rc *RClient) Go(timeout time.Duration,rpcHandler IRpcHandler,noReply bool, serviceMethod string, args interface{}, reply interface{}) *Call {
 	_, processor := GetProcessorType(args)
 	InParam, err := processor.Marshal(args)
 	if err != nil {
@@ -55,15 +52,74 @@ func (rc *RClient) Go(nodeId string,timeout time.Duration,rpcHandler IRpcHandler
 		return call
 	}
 
-	return rc.selfClient.rawGo(nodeId,rc,timeout,rpcHandler,processor, noReply, 0, serviceMethod, InParam, reply)
+	return rc.RawGo(timeout,rpcHandler,processor, noReply, 0, serviceMethod, InParam, reply)
 }
 
-func (rc *RClient) RawGo(nodeId string,timeout time.Duration,rpcHandler IRpcHandler,processor IRpcProcessor, noReply bool, rpcMethodId uint32, serviceMethod string, rawArgs []byte, reply interface{}) *Call {
-	return rc.selfClient.rawGo(nodeId,rc,timeout,rpcHandler,processor, noReply, rpcMethodId, serviceMethod, rawArgs, reply)
+func (rc *RClient) RawGo(timeout time.Duration,rpcHandler IRpcHandler,processor IRpcProcessor, noReply bool, rpcMethodId uint32, serviceMethod string, rawArgs []byte, reply interface{}) *Call {
+	call := MakeCall()
+	call.ServiceMethod = serviceMethod
+	call.Reply = reply
+	call.Seq = rc.selfClient.generateSeq()
+	call.TimeOut = timeout
+
+	request := MakeRpcRequest(processor, call.Seq, rpcMethodId, serviceMethod, noReply, rawArgs)
+	bytes, err := processor.Marshal(request.RpcRequestData)
+	ReleaseRpcRequest(request)
+
+	if err != nil {
+		call.Seq = 0
+		log.Error("marshal is fail",log.String("error",err.Error()))
+		call.DoError(err)
+		return call
+	}
+
+	conn := rc.GetConn()
+	if conn == nil || conn.IsConnected()==false {
+		call.Seq = 0
+		sErr := errors.New(serviceMethod + "  was called failed,rpc client is disconnect")
+		log.Error("conn is disconnect",log.String("error",sErr.Error()))
+		call.DoError(sErr)
+		return call
+	}
+
+	var compressBuff[]byte
+	bCompress := uint8(0)
+	if rc.compressBytesLen > 0 && len(bytes) >= rc.compressBytesLen {
+		var cErr error
+		compressBuff,cErr = compressor.CompressBlock(bytes)
+		if cErr != nil {
+			call.Seq = 0
+			log.Error("compress fail",log.String("error",cErr.Error()))
+			call.DoError(cErr)
+			return call
+		}
+		if len(compressBuff) < len(bytes) {
+			bytes = compressBuff
+			bCompress = 1<<7
+		}
+	}
+
+	if noReply == false {
+		rc.selfClient.AddPending(call)
+	}
+
+	err = conn.WriteMsg([]byte{uint8(processor.GetProcessorType())|bCompress}, bytes)
+	if cap(compressBuff) >0 {
+		compressor.CompressBufferCollection(compressBuff)
+	}
+	if err != nil {
+		rc.selfClient.RemovePending(call.Seq)
+		log.Error("WiteMsg is fail",log.ErrorAttr("error",err))
+		call.Seq = 0
+		call.DoError(err)
+	}
+
+	return call
 }
 
-func (rc *RClient) AsyncCall(nodeId string,timeout time.Duration,rpcHandler IRpcHandler, serviceMethod string, callback reflect.Value, args interface{}, replyParam interface{},cancelable bool)  (CancelRpc,error) {
-	cancelRpc,err := rc.selfClient.asyncCall(nodeId,rc,timeout,rpcHandler, serviceMethod, callback, args, replyParam,cancelable)
+
+func (rc *RClient) AsyncCall(timeout time.Duration,rpcHandler IRpcHandler, serviceMethod string, callback reflect.Value, args interface{}, replyParam interface{},cancelable bool)  (CancelRpc,error) {
+	cancelRpc,err := rc.asyncCall(timeout,rpcHandler, serviceMethod, callback, args, replyParam,cancelable)
 	if err != nil {
 		callback.Call([]reflect.Value{reflect.ValueOf(replyParam), reflect.ValueOf(err)})
 	}
@@ -71,6 +127,68 @@ func (rc *RClient) AsyncCall(nodeId string,timeout time.Duration,rpcHandler IRpc
 	return cancelRpc,nil
 }
 
+func (rc *RClient) asyncCall(timeout time.Duration,rpcHandler IRpcHandler, serviceMethod string, callback reflect.Value, args interface{}, replyParam interface{},cancelable bool) (CancelRpc,error) {
+	processorType, processor := GetProcessorType(args)
+	InParam, herr := processor.Marshal(args)
+	if herr != nil {
+		return emptyCancelRpc,herr
+	}
+
+	seq := rc.selfClient.generateSeq()
+	request := MakeRpcRequest(processor, seq, 0, serviceMethod, false, InParam)
+	bytes, err := processor.Marshal(request.RpcRequestData)
+	ReleaseRpcRequest(request)
+	if err != nil {
+		return emptyCancelRpc,err
+	}
+
+	conn := rc.GetConn()
+	if conn == nil || conn.IsConnected()==false {
+		return emptyCancelRpc,errors.New("Rpc server is disconnect,call " + serviceMethod)
+	}
+
+	var compressBuff[]byte
+	bCompress := uint8(0)
+	if rc.compressBytesLen>0 &&len(bytes) >= rc.compressBytesLen {
+		var cErr error
+		compressBuff,cErr = compressor.CompressBlock(bytes)
+		if cErr != nil {
+			return emptyCancelRpc,cErr
+		}
+
+		if len(compressBuff) < len(bytes) {
+			bytes = compressBuff
+			bCompress = 1<<7
+		}
+	}
+
+	call := MakeCall()
+	call.Reply = replyParam
+	call.callback = &callback
+	call.rpcHandler = rpcHandler
+	call.ServiceMethod = serviceMethod
+	call.Seq = seq
+	call.TimeOut = timeout
+	rc.selfClient.AddPending(call)
+
+	err = conn.WriteMsg([]byte{uint8(processorType)|bCompress}, bytes)
+	if cap(compressBuff) >0 {
+		compressor.CompressBufferCollection(compressBuff)
+	}
+	if err != nil {
+		rc.selfClient.RemovePending(call.Seq)
+		ReleaseCall(call)
+		return emptyCancelRpc,err
+	}
+
+	if cancelable {
+		rpcCancel := RpcCancel{CallSeq:seq,Cli: rc.selfClient}
+		return rpcCancel.CancelRpc,nil
+	}
+
+	return emptyCancelRpc,nil
+}
+
 func (rc *RClient) Run() {
 	defer func() {
 		if r := recover(); r != nil {
@@ -81,11 +199,7 @@ func (rc *RClient) Run() {
 		}
 	}()
 
-	var eventData RpcConnEvent
-	eventData.IsConnect = true
-	eventData.NodeId =  rc.selfClient.GetTargetNodeId()
-	rc.notifyEventFun(&eventData)
-	
+	rc.TriggerRpcConnEvent(true, rc.selfClient.GetClientId(), rc.selfClient.GetNodeId())
 	for {
 		bytes, err := rc.conn.ReadMsg()
 		if err != nil {
@@ -93,34 +207,91 @@ func (rc *RClient) Run() {
 			return
 		}
 
-		err = rc.selfClient.processRpcResponse(bytes)
-		rc.conn.ReleaseReadMsg(bytes)
-		if err != nil {
+		bCompress := (bytes[0]>>7) > 0
+		processor := GetProcessor(bytes[0]&0x7f)
+		if processor == nil {
+			rc.conn.ReleaseReadMsg(bytes)
+			log.Error("cannot find process",log.Uint8("process type",bytes[0]&0x7f))
 			return
 		}
+
+		//1.解析head
+		response := RpcResponse{}
+		response.RpcResponseData = processor.MakeRpcResponse(0, "", nil)
+
+		//解压缩
+		byteData := bytes[1:]
+		var compressBuff []byte
+
+		if bCompress == true {
+			var unCompressErr error
+			compressBuff,unCompressErr = compressor.UncompressBlock(byteData)
+			if unCompressErr!= nil {
+				rc.conn.ReleaseReadMsg(bytes)
+				log.Error("uncompressBlock failed",log.ErrorAttr("error",unCompressErr))
+				return
+			}
+			byteData = compressBuff
+		}
+
+		err = processor.Unmarshal(byteData, response.RpcResponseData)
+		if cap(compressBuff) > 0 {
+			compressor.UnCompressBufferCollection(compressBuff)
+		}
+
+		rc.conn.ReleaseReadMsg(bytes)
+		if err != nil {
+			processor.ReleaseRpcResponse(response.RpcResponseData)
+			log.Error("rpcClient Unmarshal head error",log.ErrorAttr("error",err))
+			continue
+		}
+		
+		v := rc.selfClient.RemovePending(response.RpcResponseData.GetSeq())
+		if v == nil {
+			log.Error("rpcClient cannot find seq",log.Uint64("seq",response.RpcResponseData.GetSeq()))
+		} else {
+			v.Err = nil
+			if len(response.RpcResponseData.GetReply()) > 0 {
+				err = processor.Unmarshal(response.RpcResponseData.GetReply(), v.Reply)
+				if err != nil {
+					log.Error("rpcClient Unmarshal body failed",log.ErrorAttr("error",err))
+					v.Err = err
+				}
+			}
+
+			if response.RpcResponseData.GetErr() != nil {
+				v.Err = response.RpcResponseData.GetErr()
+			}
+
+			if v.callback != nil && v.callback.IsValid() {
+				v.rpcHandler.PushRpcResponse(v)
+			} else {
+				v.done <- v
+			}
+		}
+
+		processor.ReleaseRpcResponse(response.RpcResponseData)
 	}
 }
 
 func (rc *RClient) OnClose() {
-	var connEvent RpcConnEvent
-	connEvent.IsConnect = false
-	connEvent.NodeId = rc.selfClient.GetTargetNodeId()
-	rc.notifyEventFun(&connEvent)
+	rc.TriggerRpcConnEvent(false, rc.selfClient.GetClientId(), rc.selfClient.GetNodeId())
 }
 
-func NewRClient(targetNodeId string, addr string, maxRpcParamLen uint32,compressBytesLen int,callSet *CallSet,notifyEventFun NotifyEventFun) *Client{
+func NewRClient(nodeId int, addr string, maxRpcParamLen uint32,compressBytesLen int,triggerRpcConnEvent TriggerRpcConnEvent) *Client{
 	client := &Client{}
 	client.clientId = atomic.AddUint32(&clientSeq, 1)
-	client.targetNodeId = targetNodeId
-	client.compressBytesLen = compressBytesLen
-
+	client.nodeId = nodeId
+	client.maxCheckCallRpcCount = DefaultMaxCheckCallRpcCount
+	client.callRpcTimeout = DefaultRpcTimeout
 	c:= &RClient{}
+	c.compressBytesLen = compressBytesLen
 	c.selfClient = client
 	c.Addr = addr
 	c.ConnectInterval = DefaultConnectInterval
 	c.PendingWriteNum = DefaultMaxPendingWriteNum
 	c.AutoReconnect = true
-	c.notifyEventFun = notifyEventFun
+	c.TriggerRpcConnEvent = triggerRpcConnEvent
 	c.ConnNum = DefaultRpcConnNum
 	c.LenMsgLen = DefaultRpcLenMsgLen
 	c.MinMsgLen = DefaultRpcMinMsgLen
@@ -135,7 +306,8 @@ func NewRClient(targetNodeId string, addr string, maxRpcParamLen uint32,compress
 		c.MaxMsgLen = math.MaxUint32
 	}
 	client.IRealClient = c
-	client.CallSet = callSet
+	client.InitPending()
+	go client.checkRpcCallTimeout()
 	c.Start()
 	return client
 }
@@ -146,7 +318,3 @@ func (rc *RClient) Close(waitDone bool) {
 	rc.selfClient.cleanPending()
 }
 
-
-func (rc *RClient) Bind(server IServer){
-
-}

rpc/rpc.go

@@ -1,7 +1,7 @@
 package rpc
 
 import (
-	"github.com/duanhf2012/origin/v2/util/sync"
+	"github.com/duanhf2012/origin/util/sync"
 	"reflect"
 	"time"
 )

rpc/rpcevent.go

@@ -1,23 +0,0 @@
-package rpc
-
-import "github.com/duanhf2012/origin/v2/event"
-
-type NotifyEventFun func (event event.IEvent)
-
-// RpcConnEvent Node结点连接事件
-type RpcConnEvent struct{
-	IsConnect bool
-	NodeId string
-}
-
-func (rc *RpcConnEvent) GetEventType() event.EventType{
-	return event.Sys_Event_Node_Conn_Event
-}
-
-type NatsConnEvent struct {
-	IsConnect bool
-}
-
-func (nc *NatsConnEvent)  GetEventType() event.EventType{
-	return event.Sys_Event_Nats_Conn_Event
-}

rpc/rpchandler.go

@@ -3,21 +3,20 @@ package rpc
 import (
 	"errors"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"reflect"
 	"runtime"
 	"strings"
 	"unicode"
 	"unicode/utf8"
-	"github.com/duanhf2012/origin/v2/event"
 	"time"
 )
 
 const maxClusterNode int = 128
 
-type FuncRpcClient func(nodeId string, serviceMethod string,filterRetire bool, client []*Client) (error, int)
-type FuncRpcServer func() IServer
-const NodeIdNull = ""
+type FuncRpcClient func(nodeId int, serviceMethod string,filterRetire bool, client []*Client) (error, int)
+type FuncRpcServer func() *Server
+
 
 var nilError = reflect.Zero(reflect.TypeOf((*error)(nil)).Elem())
 
@@ -66,22 +65,15 @@ type RpcHandler struct {
 	pClientList []*Client
 }
 
-//type TriggerRpcConnEvent func(bConnect bool, clientSeq uint32, nodeId string)
-type NotifyEventToAllService func(event event.IEvent)
-
-type INodeConnListener interface {
-	OnNodeConnected(nodeId string)
-	OnNodeDisconnect(nodeId string)
-}
-
-type INatsConnListener interface {
-	OnNatsConnected()
-	OnNatsDisconnect()
+type TriggerRpcConnEvent func(bConnect bool, clientSeq uint32, nodeId int)
+type INodeListener interface {
+	OnNodeConnected(nodeId int)
+	OnNodeDisconnect(nodeId int)
 }
 
 type IDiscoveryServiceListener interface {
-	OnDiscoveryService(nodeId string, serviceName []string)
-	OnUnDiscoveryService(nodeId string, serviceName []string)
+	OnDiscoveryService(nodeId int, serviceName []string)
+	OnUnDiscoveryService(nodeId int)
 }
 
 type CancelRpc func()
@@ -97,18 +89,18 @@ type IRpcHandler interface {
 	CallMethod(client *Client,ServiceMethod string, param interface{},callBack reflect.Value, reply interface{}) error
 
 	Call(serviceMethod string, args interface{}, reply interface{}) error
-	CallNode(nodeId string, serviceMethod string, args interface{}, reply interface{}) error
+	CallNode(nodeId int, serviceMethod string, args interface{}, reply interface{}) error
 	AsyncCall(serviceMethod string, args interface{}, callback interface{}) error
-	AsyncCallNode(nodeId string, serviceMethod string, args interface{}, callback interface{}) error
+	AsyncCallNode(nodeId int, serviceMethod string, args interface{}, callback interface{}) error
 
 	CallWithTimeout(timeout time.Duration,serviceMethod string, args interface{}, reply interface{}) error
-	CallNodeWithTimeout(timeout time.Duration,nodeId string, serviceMethod string, args interface{}, reply interface{}) error
+	CallNodeWithTimeout(timeout time.Duration,nodeId int, serviceMethod string, args interface{}, reply interface{}) error
 	AsyncCallWithTimeout(timeout time.Duration,serviceMethod string, args interface{}, callback interface{})  (CancelRpc,error)
-	AsyncCallNodeWithTimeout(timeout time.Duration,nodeId string, serviceMethod string, args interface{}, callback interface{})  (CancelRpc,error)
+	AsyncCallNodeWithTimeout(timeout time.Duration,nodeId int, serviceMethod string, args interface{}, callback interface{})  (CancelRpc,error)
 
 	Go(serviceMethod string, args interface{}) error
-	GoNode(nodeId string, serviceMethod string, args interface{}) error
-	RawGoNode(rpcProcessorType RpcProcessorType, nodeId string, rpcMethodId uint32, serviceName string, rawArgs []byte) error
+	GoNode(nodeId int, serviceMethod string, args interface{}) error
+	RawGoNode(rpcProcessorType RpcProcessorType, nodeId int, 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)
@@ -434,7 +426,7 @@ func (handler *RpcHandler) CallMethod(client *Client,ServiceMethod string, param
 	return err
 }
 
-func (handler *RpcHandler) goRpc(processor IRpcProcessor, bCast bool, nodeId string, serviceMethod string, args interface{}) error {
+func (handler *RpcHandler) goRpc(processor IRpcProcessor, bCast bool, nodeId int, serviceMethod string, args interface{}) error {
 	var pClientList [maxClusterNode]*Client
 	err, count := handler.funcRpcClient(nodeId, serviceMethod,false, pClientList[:])
 	if count == 0 {
@@ -453,7 +445,7 @@ func (handler *RpcHandler) goRpc(processor IRpcProcessor, bCast bool, nodeId str
 
 	//2.rpcClient调用
 	for i := 0; i < count; i++ {
-		pCall := pClientList[i].Go(pClientList[i].GetTargetNodeId(),DefaultRpcTimeout,handler.rpcHandler,true, serviceMethod, args, nil)
+		pCall := pClientList[i].Go(DefaultRpcTimeout,handler.rpcHandler,true, serviceMethod, args, nil)
 		if pCall.Err != nil {
 			err = pCall.Err
 		}
@@ -464,7 +456,7 @@ func (handler *RpcHandler) goRpc(processor IRpcProcessor, bCast bool, nodeId str
 	return err
 }
 
-func (handler *RpcHandler) callRpc(timeout time.Duration,nodeId string, serviceMethod string, args interface{}, reply interface{}) error {
+func (handler *RpcHandler) callRpc(timeout time.Duration,nodeId int, serviceMethod string, args interface{}, reply interface{}) error {
 	var pClientList [maxClusterNode]*Client
 	err, count := handler.funcRpcClient(nodeId, serviceMethod,false, pClientList[:])
 	if err != nil {
@@ -480,7 +472,7 @@ func (handler *RpcHandler) callRpc(timeout time.Duration,nodeId string, serviceM
 	}
 
 	pClient := pClientList[0]
-	pCall := pClient.Go(pClient.GetTargetNodeId(),timeout,handler.rpcHandler,false, serviceMethod, args, reply)
+	pCall := pClient.Go(timeout,handler.rpcHandler,false, serviceMethod, args, reply)
 
 	err = pCall.Done().Err
 	pClient.RemovePending(pCall.Seq)
@@ -488,7 +480,7 @@ func (handler *RpcHandler) callRpc(timeout time.Duration,nodeId string, serviceM
 	return err
 }
 
-func (handler *RpcHandler) asyncCallRpc(timeout time.Duration,nodeId string, serviceMethod string, args interface{}, callback interface{}) (CancelRpc,error) {
+func (handler *RpcHandler) asyncCallRpc(timeout time.Duration,nodeId int, serviceMethod string, args interface{}, callback interface{}) (CancelRpc,error) {
 	fVal := reflect.ValueOf(callback)
 	if fVal.Kind() != reflect.Func {
 		err := errors.New("call " + serviceMethod + " input callback param is error!")
@@ -513,14 +505,14 @@ func (handler *RpcHandler) asyncCallRpc(timeout time.Duration,nodeId string, ser
 	err, count := handler.funcRpcClient(nodeId, serviceMethod,false, pClientList[:])
 	if count == 0 || err != nil {
 		if err == nil {
-			if nodeId  != NodeIdNull {
+			if nodeId  > 0 {
 				err = fmt.Errorf("cannot find %s from nodeId %d",serviceMethod,nodeId)
 			}else {
 				err = fmt.Errorf("No %s service found in the origin network",serviceMethod)
 			}
 		}
 		fVal.Call([]reflect.Value{reflect.ValueOf(reply), reflect.ValueOf(err)})
-		log.Error("cannot find serviceMethod from node",log.String("serviceMethod",serviceMethod),log.String("nodeId",nodeId))
+		log.Error("cannot find serviceMethod from node",log.String("serviceMethod",serviceMethod),log.Int("nodeId",nodeId))
 		return emptyCancelRpc,nil
 	}
 
@@ -533,7 +525,7 @@ func (handler *RpcHandler) asyncCallRpc(timeout time.Duration,nodeId string, ser
 
 	//2.rpcClient调用
 	//如果调用本结点服务
-	return pClientList[0].AsyncCall(pClientList[0].GetTargetNodeId(),timeout,handler.rpcHandler, serviceMethod, fVal, args, reply,false)
+	return pClientList[0].AsyncCall(timeout,handler.rpcHandler, serviceMethod, fVal, args, reply,false)
 }
 
 func (handler *RpcHandler) GetName() string {
@@ -545,53 +537,53 @@ func (handler *RpcHandler) IsSingleCoroutine() bool {
 }
 
 func (handler *RpcHandler) CallWithTimeout(timeout time.Duration,serviceMethod string, args interface{}, reply interface{}) error {
-	return handler.callRpc(timeout,NodeIdNull, serviceMethod, args, reply)
+	return handler.callRpc(timeout,0, serviceMethod, args, reply)
 }
 
-func (handler *RpcHandler) CallNodeWithTimeout(timeout time.Duration,nodeId string, serviceMethod string, args interface{}, reply interface{})  error{
+func (handler *RpcHandler) CallNodeWithTimeout(timeout time.Duration,nodeId int, serviceMethod string, args interface{}, reply interface{})  error{
 	return handler.callRpc(timeout,nodeId, serviceMethod, args, reply)
 }
 
 func (handler *RpcHandler) AsyncCallWithTimeout(timeout time.Duration,serviceMethod string, args interface{}, callback interface{})  (CancelRpc,error){
-	return handler.asyncCallRpc(timeout,NodeIdNull, serviceMethod, args, callback)
+	return handler.asyncCallRpc(timeout,0, serviceMethod, args, callback)
 }
 
-func (handler *RpcHandler) AsyncCallNodeWithTimeout(timeout time.Duration,nodeId string, serviceMethod string, args interface{}, callback interface{})  (CancelRpc,error){
+func (handler *RpcHandler) AsyncCallNodeWithTimeout(timeout time.Duration,nodeId int, serviceMethod string, args interface{}, callback interface{})  (CancelRpc,error){
 	return handler.asyncCallRpc(timeout,nodeId, serviceMethod, args, callback)
 }
 
 func (handler *RpcHandler) AsyncCall(serviceMethod string, args interface{}, callback interface{}) error {
-	_,err := handler.asyncCallRpc(DefaultRpcTimeout,NodeIdNull, serviceMethod, args, callback)
+	_,err := handler.asyncCallRpc(DefaultRpcTimeout,0, serviceMethod, args, callback)
 	return err
 }
 
 func (handler *RpcHandler) Call(serviceMethod string, args interface{}, reply interface{}) error {
-	return handler.callRpc(DefaultRpcTimeout,NodeIdNull, serviceMethod, args, reply)
+	return handler.callRpc(DefaultRpcTimeout,0, serviceMethod, args, reply)
 }
 
 func (handler *RpcHandler) Go(serviceMethod string, args interface{}) error {
-	return handler.goRpc(nil, false, NodeIdNull, serviceMethod, args)
+	return handler.goRpc(nil, false, 0, serviceMethod, args)
 }
 
-func (handler *RpcHandler) AsyncCallNode(nodeId string, serviceMethod string, args interface{}, callback interface{}) error {
+func (handler *RpcHandler) AsyncCallNode(nodeId int, serviceMethod string, args interface{}, callback interface{}) error {
 	_,err:= handler.asyncCallRpc(DefaultRpcTimeout,nodeId, serviceMethod, args, callback)
 
 	return err
 }
 
-func (handler *RpcHandler) CallNode(nodeId string, serviceMethod string, args interface{}, reply interface{}) error {
+func (handler *RpcHandler) CallNode(nodeId int, serviceMethod string, args interface{}, reply interface{}) error {
 	return handler.callRpc(DefaultRpcTimeout,nodeId, serviceMethod, args, reply)
 }
 
-func (handler *RpcHandler) GoNode(nodeId string, serviceMethod string, args interface{}) error {
+func (handler *RpcHandler) GoNode(nodeId int, serviceMethod string, args interface{}) error {
 	return handler.goRpc(nil, false, nodeId, serviceMethod, args)
 }
 
 func (handler *RpcHandler) CastGo(serviceMethod string, args interface{}) error {
-	return handler.goRpc(nil, true, NodeIdNull, serviceMethod, args)
+	return handler.goRpc(nil, true, 0, serviceMethod, args)
 }
 
-func (handler *RpcHandler) RawGoNode(rpcProcessorType RpcProcessorType, nodeId string, rpcMethodId uint32, serviceName string, rawArgs []byte) error {
+func (handler *RpcHandler) RawGoNode(rpcProcessorType RpcProcessorType, nodeId int, rpcMethodId uint32, serviceName string, rawArgs []byte) error {
 	processor := GetProcessor(uint8(rpcProcessorType))
 	err, count := handler.funcRpcClient(nodeId, serviceName,false, handler.pClientList)
 	if count == 0 || err != nil {
@@ -608,7 +600,7 @@ func (handler *RpcHandler) RawGoNode(rpcProcessorType RpcProcessorType, nodeId s
 	//如果调用本结点服务
 	for i := 0; i < count; i++ {
 		//跨node调用
-		pCall := handler.pClientList[i].RawGo(handler.pClientList[i].GetTargetNodeId(),DefaultRpcTimeout,handler.rpcHandler,processor, true, rpcMethodId, serviceName, rawArgs, nil)
+		pCall := handler.pClientList[i].RawGo(DefaultRpcTimeout,handler.rpcHandler,processor, true, rpcMethodId, serviceName, rawArgs, nil)
 		if pCall.Err != nil {
 			err = pCall.Err
 		}

rpc/rpcnats.go

@@ -1,42 +0,0 @@
-package rpc
-
-import "sync/atomic"
-
-type RpcNats struct {
-	NatsServer
-	NatsClient
-}
-
-func (rn *RpcNats) Start() error{
-	err := rn.NatsServer.Start()
-	if err != nil {
-		return err
-	}
-
-	return rn.NatsClient.Start(rn.NatsServer.natsConn)
-}
-
-func (rn *RpcNats) Init(natsUrl string, noRandomize bool, nodeId string,compressBytesLen int,rpcHandleFinder RpcHandleFinder,notifyEventFun NotifyEventFun){
-	rn.NatsClient.localNodeId = nodeId
-	rn.NatsServer.initServer(natsUrl,noRandomize, nodeId,compressBytesLen,rpcHandleFinder,notifyEventFun)
-	rn.NatsServer.iServer = rn
-}
-
-func  (rn *RpcNats) NewNatsClient(targetNodeId string,localNodeId string,callSet *CallSet,notifyEventFun NotifyEventFun) *Client{
-	var client Client
-
-	client.clientId = atomic.AddUint32(&clientSeq, 1)
-	client.targetNodeId = targetNodeId
-	//client.maxCheckCallRpcCount = DefaultMaxCheckCallRpcCount
-	//client.callRpcTimeout = DefaultRpcTimeout
-
-	natsClient := &rn.NatsClient
-	natsClient.localNodeId = localNodeId
-	natsClient.client = &client
-	natsClient.notifyEventFun = notifyEventFun
-
-	client.IRealClient = natsClient
-	client.CallSet = callSet
-
-	return &client
-}

rpc/server.go

@@ -1,9 +1,10 @@
 package rpc
 
 import (
+	"errors"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/network"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/network"
 	"math"
 	"net"
 	"reflect"
@@ -12,7 +13,6 @@ import (
 	"runtime"
 )
 
-const Default_ReadWriteDeadline = 15*time.Second
 type RpcProcessorType uint8
 
 const (
@@ -24,25 +24,12 @@ var arrayProcessor = []IRpcProcessor{&JsonProcessor{}, &PBProcessor{}}
 var arrayProcessorLen uint8 = 2
 var LittleEndian bool
 
-type IServer interface {
-	Start() error
-	Stop()
-
-	selfNodeRpcHandlerGo(timeout time.Duration,processor IRpcProcessor, client *Client, noReply bool, handlerName string, rpcMethodId uint32, serviceMethod string, args interface{}, reply interface{}, rawArgs []byte) *Call
-	myselfRpcHandlerGo(client *Client,handlerName string, serviceMethod string, args interface{},callBack reflect.Value, reply interface{}) error
-	selfNodeRpcHandlerAsyncGo(timeout time.Duration,client *Client, callerRpcHandler IRpcHandler, noReply bool, handlerName string, serviceMethod string, args interface{}, reply interface{}, callback reflect.Value,cancelable bool) (CancelRpc,error)
-}
-
-type  writeResponse func(processor IRpcProcessor,connTag string, serviceMethod string, seq uint64, reply interface{}, rpcError RpcError)
-
 type Server struct {
-	BaseServer
-
 	functions       map[interface{}]interface{}
+	rpcHandleFinder RpcHandleFinder
 	rpcServer       *network.TCPServer
 
-	listenAddr string
-	maxRpcParamLen uint32
+	compressBytesLen int
 }
 
 type RpcAgent struct {
@@ -73,25 +60,24 @@ func GetProcessor(processorType uint8) IRpcProcessor {
 	return arrayProcessor[processorType]
 }
 
-func (server *Server) Init(listenAddr string, maxRpcParamLen uint32,compressBytesLen int,rpcHandleFinder RpcHandleFinder) {
-	server.initBaseServer(compressBytesLen,rpcHandleFinder)
-	server.listenAddr = listenAddr
-	server.maxRpcParamLen = maxRpcParamLen
-
+func (server *Server) Init(rpcHandleFinder RpcHandleFinder) {
+	server.rpcHandleFinder = rpcHandleFinder
 	server.rpcServer = &network.TCPServer{}
 }
 
-func (server *Server) Start() error{
-	splitAddr := strings.Split(server.listenAddr, ":")
+const Default_ReadWriteDeadline = 15*time.Second
+
+func (server *Server) Start(listenAddr string, maxRpcParamLen uint32,compressBytesLen int) {
+	splitAddr := strings.Split(listenAddr, ":")
 	if len(splitAddr) != 2 {
-		return fmt.Errorf("listen addr is failed,listenAddr:%s", server.listenAddr)
+		log.Fatal("listen addr is failed", log.String("listenAddr",listenAddr))
 	}
 
 	server.rpcServer.Addr = ":" + splitAddr[1]
 	server.rpcServer.MinMsgLen = 2
-	server.compressBytesLen = server.compressBytesLen
-	if server.maxRpcParamLen > 0 {
-		server.rpcServer.MaxMsgLen = server.maxRpcParamLen
+	server.compressBytesLen = compressBytesLen
+	if maxRpcParamLen > 0 {
+		server.rpcServer.MaxMsgLen = maxRpcParamLen
 	} else {
 		server.rpcServer.MaxMsgLen = math.MaxUint32
 	}
@@ -104,16 +90,12 @@ func (server *Server) Start() error{
 	server.rpcServer.ReadDeadline = Default_ReadWriteDeadline
 	server.rpcServer.LenMsgLen = DefaultRpcLenMsgLen
 
-	return server.rpcServer.Start()
-}
-
-func (server *Server) Stop(){
-	server.rpcServer.Close()
+	server.rpcServer.Start()
 }
 
 func (agent *RpcAgent) OnDestroy() {}
 
-func (agent *RpcAgent) WriteResponse(processor IRpcProcessor, connTag string, serviceMethod string, seq uint64, reply interface{}, rpcError RpcError) {
+func (agent *RpcAgent) WriteResponse(processor IRpcProcessor, serviceMethod string, seq uint64, reply interface{}, rpcError RpcError) {
 	var mReply []byte
 	var errM error
 
@@ -177,12 +159,102 @@ func (agent *RpcAgent) Run() {
 			break
 		}
 
-		defer agent.conn.ReleaseReadMsg(data)
-		err = agent.rpcServer.processRpcRequest( data,"",agent.WriteResponse)
+		bCompress := (data[0]>>7) > 0
+		processor := GetProcessor(data[0]&0x7f)
+		if processor == nil {
+			agent.conn.ReleaseReadMsg(data)
+			log.Warning("cannot find processor",log.String("RemoteAddr",agent.conn.RemoteAddr().String()))
+			return
+		}
+
+		//解析head
+		var compressBuff []byte
+		byteData := data[1:]
+		if bCompress == true {
+			var unCompressErr error
+
+			compressBuff,unCompressErr = compressor.UncompressBlock(byteData)
+			if unCompressErr!= nil {
+				agent.conn.ReleaseReadMsg(data)
+				log.Error("UncompressBlock failed",log.String("RemoteAddr",agent.conn.RemoteAddr().String()),log.ErrorAttr("error",unCompressErr))
+				return
+			}
+			byteData = compressBuff
+		}
+
+		req := MakeRpcRequest(processor, 0, 0, "", false, nil)
+		err = processor.Unmarshal(byteData, req.RpcRequestData)
+		if cap(compressBuff) > 0 {
+			compressor.UnCompressBufferCollection(compressBuff)
+		}
+		agent.conn.ReleaseReadMsg(data)
 		if err != nil {
-			log.Error("processRpcRequest is error",log.String("remoteAddress",agent.conn.RemoteAddr().String()),log.ErrorAttr("error",err))
-			//will close tcpconn
-			break
+			log.Error("Unmarshal failed",log.String("RemoteAddr",agent.conn.RemoteAddr().String()),log.ErrorAttr("error",err))
+			if req.RpcRequestData.GetSeq() > 0 {
+				rpcError := RpcError(err.Error())
+				if req.RpcRequestData.IsNoReply() == false {
+					agent.WriteResponse(processor, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), nil, rpcError)
+				}
+				ReleaseRpcRequest(req)
+				continue
+			} else {
+				ReleaseRpcRequest(req)
+				break
+			}
+		}
+
+		//交给程序处理
+		serviceMethod := strings.Split(req.RpcRequestData.GetServiceMethod(), ".")
+		if len(serviceMethod) < 1 {
+			rpcError := RpcError("rpc request req.ServiceMethod is error")
+			if req.RpcRequestData.IsNoReply() == false {
+				agent.WriteResponse(processor, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), nil, rpcError)
+			}
+			ReleaseRpcRequest(req)
+			log.Error("rpc request req.ServiceMethod is error")
+			continue
+		}
+
+		rpcHandler := agent.rpcServer.rpcHandleFinder.FindRpcHandler(serviceMethod[0])
+		if rpcHandler == nil {
+			rpcError := RpcError(fmt.Sprintf("service method %s not config!", req.RpcRequestData.GetServiceMethod()))
+			if req.RpcRequestData.IsNoReply() == false {
+				agent.WriteResponse(processor, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), nil, rpcError)
+			}
+			log.Error("serviceMethod not config",log.String("serviceMethod",req.RpcRequestData.GetServiceMethod()))
+			ReleaseRpcRequest(req)
+			continue
+		}
+
+		if req.RpcRequestData.IsNoReply() == false {
+			req.requestHandle = func(Returns interface{}, Err RpcError) {
+				agent.WriteResponse(processor, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), Returns, Err)
+				ReleaseRpcRequest(req)
+			}
+		}
+
+		req.inParam, err = rpcHandler.UnmarshalInParam(req.rpcProcessor, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetRpcMethodId(), req.RpcRequestData.GetInParam())
+		if err != nil {
+			rErr := "Call Rpc " + req.RpcRequestData.GetServiceMethod() + " Param error " + err.Error()
+			log.Error("call rpc param error",log.String("serviceMethod",req.RpcRequestData.GetServiceMethod()),log.ErrorAttr("error",err))
+			if req.requestHandle != nil {
+				req.requestHandle(nil, RpcError(rErr))
+			} else {
+				ReleaseRpcRequest(req)
+			}
+
+			continue
+		}
+
+		err = rpcHandler.PushRpcRequest(req)
+		if err != nil {
+			rpcError := RpcError(err.Error())
+
+			if req.RpcRequestData.IsNoReply() {
+				agent.WriteResponse(processor, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), nil, rpcError)
+			}
+
+			ReleaseRpcRequest(req)
 		}
 	}
 }
@@ -215,3 +287,174 @@ func (server *Server) NewAgent(c *network.TCPConn) network.Agent {
 	return agent
 }
 
+func (server *Server) myselfRpcHandlerGo(client *Client,handlerName string, serviceMethod string, args interface{},callBack reflect.Value, reply interface{}) error {
+	rpcHandler := server.rpcHandleFinder.FindRpcHandler(handlerName)
+	if rpcHandler == nil {
+		err := errors.New("service method " + serviceMethod + " not config!")
+		log.Error("service method not config",log.String("serviceMethod",serviceMethod))
+		return err
+	}
+	
+	return rpcHandler.CallMethod(client,serviceMethod, args,callBack, reply)
+}
+
+func (server *Server) selfNodeRpcHandlerGo(timeout time.Duration,processor IRpcProcessor, client *Client, noReply bool, handlerName string, rpcMethodId uint32, serviceMethod string, args interface{}, reply interface{}, rawArgs []byte) *Call {
+	pCall := MakeCall()
+	pCall.Seq = client.generateSeq()
+	pCall.TimeOut = timeout
+	pCall.ServiceMethod = serviceMethod
+
+	rpcHandler := server.rpcHandleFinder.FindRpcHandler(handlerName)
+	if rpcHandler == nil {
+		err := errors.New("service method " + serviceMethod + " not config!")
+		log.Error("service method not config",log.String("serviceMethod",serviceMethod),log.ErrorAttr("error",err))
+		pCall.Seq = 0
+		pCall.DoError(err)
+
+		return pCall
+	}
+
+	var iParam interface{}
+	if processor == nil {
+		_, processor = GetProcessorType(args)
+	}
+
+	if args != nil {
+		var err error
+		iParam,err = processor.Clone(args)
+		if err != nil {
+			sErr := errors.New("RpcHandler " + handlerName + "."+serviceMethod+" deep copy inParam is error:" + err.Error())
+			log.Error("deep copy inParam is failed",log.String("handlerName",handlerName),log.String("serviceMethod",serviceMethod))
+			pCall.Seq = 0
+			pCall.DoError(sErr)
+
+			return pCall
+		}
+	}
+
+	req := MakeRpcRequest(processor, 0, rpcMethodId, serviceMethod, noReply, nil)
+	req.inParam = iParam
+	req.localReply = reply
+	if rawArgs != nil {
+		var err error
+		req.inParam, err = rpcHandler.UnmarshalInParam(processor, serviceMethod, rpcMethodId, rawArgs)
+		if err != nil {
+			log.Error("unmarshalInParam is failed",log.String("serviceMethod",serviceMethod),log.Uint32("rpcMethodId",rpcMethodId),log.ErrorAttr("error",err))
+			pCall.Seq = 0
+			pCall.DoError(err)
+			ReleaseRpcRequest(req)
+			return pCall
+		}
+	}
+
+	if noReply == false {
+		client.AddPending(pCall)
+		callSeq := pCall.Seq
+		req.requestHandle = func(Returns interface{}, Err RpcError) {
+			if reply != nil && Returns != reply && Returns != nil {
+				byteReturns, err := req.rpcProcessor.Marshal(Returns)
+				if err != nil {
+					Err = ConvertError(err)
+					log.Error("returns data cannot be marshal",log.Uint64("seq",callSeq),log.ErrorAttr("error",err))
+				}else{
+					err = req.rpcProcessor.Unmarshal(byteReturns, reply)
+					if err != nil {
+						Err = ConvertError(err)
+						log.Error("returns data cannot be Unmarshal",log.Uint64("seq",callSeq),log.ErrorAttr("error",err))
+					}
+				}
+			}
+
+			ReleaseRpcRequest(req)
+			v := client.RemovePending(callSeq)
+			if v == nil {
+				log.Error("rpcClient cannot find seq",log.Uint64("seq",callSeq))
+				return
+			}
+
+			if len(Err) == 0 {
+				v.Err = nil
+				v.DoOK()
+			} else {
+				log.Error(Err.Error())
+				v.DoError(Err)
+			}
+		}
+	}
+
+	err := rpcHandler.PushRpcRequest(req)
+	if err != nil {
+		log.Error(err.Error())
+		pCall.DoError(err)
+		ReleaseRpcRequest(req)
+	}
+
+	return pCall
+}
+
+func (server *Server) selfNodeRpcHandlerAsyncGo(timeout time.Duration,client *Client, callerRpcHandler IRpcHandler, noReply bool, handlerName string, serviceMethod string, args interface{}, reply interface{}, callback reflect.Value,cancelable bool) (CancelRpc,error)  {
+	rpcHandler := server.rpcHandleFinder.FindRpcHandler(handlerName)
+	if rpcHandler == nil {
+		err := errors.New("service method " + serviceMethod + " not config!")
+		log.Error(err.Error())
+		return emptyCancelRpc,err
+	}
+
+	_, processor := GetProcessorType(args)
+	iParam,err := processor.Clone(args)
+	if err != nil {
+		errM := errors.New("RpcHandler " + handlerName + "."+serviceMethod+" deep copy inParam is error:" + err.Error())
+		log.Error(errM.Error())
+		return emptyCancelRpc,errM
+	}
+
+	req := MakeRpcRequest(processor, 0, 0, serviceMethod, noReply, nil)
+	req.inParam = iParam
+	req.localReply = reply
+
+	cancelRpc := emptyCancelRpc
+	var callSeq uint64
+	if noReply == false {
+		callSeq = client.generateSeq()
+		pCall := MakeCall()
+		pCall.Seq = callSeq
+		pCall.rpcHandler = callerRpcHandler
+		pCall.callback = &callback
+		pCall.Reply = reply
+		pCall.ServiceMethod = serviceMethod
+		pCall.TimeOut = timeout
+		client.AddPending(pCall)
+		rpcCancel :=  RpcCancel{CallSeq: callSeq,Cli: client}
+		cancelRpc = rpcCancel.CancelRpc
+
+		req.requestHandle = func(Returns interface{}, Err RpcError) {
+			v := client.RemovePending(callSeq)
+			if v == nil {
+				ReleaseRpcRequest(req)
+				return
+			}
+			if len(Err) == 0 {
+				v.Err = nil
+			} else {
+				v.Err = Err
+			}
+
+			if Returns != nil {
+				v.Reply = Returns
+			}
+			v.rpcHandler.PushRpcResponse(v)
+			ReleaseRpcRequest(req)
+		}
+	}
+
+	err = rpcHandler.PushRpcRequest(req)
+	if err != nil {
+		ReleaseRpcRequest(req)
+		if callSeq > 0 {
+			client.RemovePending(callSeq)
+		}
+		return emptyCancelRpc,err
+	}
+
+	return cancelRpc,nil
+}

service/module.go

@@ -6,11 +6,11 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/duanhf2012/origin/v2/event"
-	"github.com/duanhf2012/origin/v2/log"
-	rpcHandle "github.com/duanhf2012/origin/v2/rpc"
-	"github.com/duanhf2012/origin/v2/util/timer"
-	"github.com/duanhf2012/origin/v2/concurrent"
+	"github.com/duanhf2012/origin/event"
+	"github.com/duanhf2012/origin/log"
+	rpcHandle "github.com/duanhf2012/origin/rpc"
+	"github.com/duanhf2012/origin/util/timer"
+	"github.com/duanhf2012/origin/concurrent"
 )
 
 const InitModuleId = 1e9

service/service.go

@@ -3,17 +3,17 @@ package service
 import (
 	"errors"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/event"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/profiler"
-	"github.com/duanhf2012/origin/v2/rpc"
-	"github.com/duanhf2012/origin/v2/util/timer"
+	"github.com/duanhf2012/origin/event"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/profiler"
+	"github.com/duanhf2012/origin/rpc"
+	"github.com/duanhf2012/origin/util/timer"
 	"reflect"
 	"runtime"
 	"strconv"
 	"sync"
 	"sync/atomic"
-	"github.com/duanhf2012/origin/v2/concurrent"
+	"github.com/duanhf2012/origin/concurrent"
 )
 
 var timerDispatcherLen = 100000
@@ -58,31 +58,23 @@ type Service struct {
 	retire int32
 	eventProcessor event.IEventProcessor
 	profiler *profiler.Profiler //性能分析器
-	nodeConnLister rpc.INodeConnListener
-	natsConnListener rpc.INatsConnListener
+	nodeEventLister rpc.INodeListener
 	discoveryServiceLister rpc.IDiscoveryServiceListener
 	chanEvent chan event.IEvent
 	closeSig chan struct{}
 }
 
-
+// RpcConnEvent Node结点连接事件
+type RpcConnEvent struct{
+	IsConnect bool
+	NodeId int
+}
 
 // DiscoveryServiceEvent 发现服务结点
 type DiscoveryServiceEvent struct{
 	IsDiscovery bool
 	ServiceName []string
-	NodeId string
-}
-
-type EtcdServiceRecordEvent struct {
-	NetworkName string
-	TTLSecond int64
-	RecordKey string
-	RecordInfo string
-}
-
-type Empty struct {
-
+	NodeId int
 }
 
 func SetMaxServiceChannel(maxEventChannel int){
@@ -93,6 +85,9 @@ func (rpcEventData *DiscoveryServiceEvent)  GetEventType() event.EventType{
 	return event.Sys_Event_DiscoverService
 }
 
+func (rpcEventData *RpcConnEvent) GetEventType() event.EventType{
+	return event.Sys_Event_Node_Event
+}
 
 func (s *Service) OnSetup(iService IService){
 	if iService.GetName() == "" {
@@ -316,21 +311,12 @@ func (s *Service) RegRawRpc(rpcMethodId uint32,rawRpcCB rpc.RawRpcCallBack){
 func (s *Service) OnStart(){
 }
 
-func (s *Service) OnNodeConnEvent(ev event.IEvent){
-	event := ev.(*rpc.RpcConnEvent)
+func (s *Service) OnNodeEvent(ev event.IEvent){
+	event := ev.(*RpcConnEvent)
 	if event.IsConnect {
-		s.nodeConnLister.OnNodeConnected(event.NodeId)
+		s.nodeEventLister.OnNodeConnected(event.NodeId)
 	}else{
-		s.nodeConnLister.OnNodeDisconnect(event.NodeId)
-	}
-}
-
-func (s *Service) OnNatsConnEvent(ev event.IEvent){
-	event := ev.(*rpc.NatsConnEvent)
-	if event.IsConnect {
-		s.natsConnListener.OnNatsConnected()
-	}else{
-		s.natsConnListener.OnNatsDisconnect()
+		s.nodeEventLister.OnNodeDisconnect(event.NodeId)
 	}
 }
 
@@ -339,29 +325,18 @@ func (s *Service) OnDiscoverServiceEvent(ev event.IEvent){
 	if event.IsDiscovery {
 		s.discoveryServiceLister.OnDiscoveryService(event.NodeId,event.ServiceName)
 	}else{
-		s.discoveryServiceLister.OnUnDiscoveryService(event.NodeId,event.ServiceName)
+		s.discoveryServiceLister.OnUnDiscoveryService(event.NodeId)
 	}
 }
 
-func (s *Service) RegNodeConnListener(nodeConnListener rpc.INodeConnListener) {
-	s.nodeConnLister = nodeConnListener
-	s.RegEventReceiverFunc(event.Sys_Event_Node_Conn_Event,s.GetEventHandler(),s.OnNodeConnEvent)
+func (s *Service) RegRpcListener(rpcEventLister rpc.INodeListener) {
+	s.nodeEventLister = rpcEventLister
+	s.RegEventReceiverFunc(event.Sys_Event_Node_Event,s.GetEventHandler(),s.OnNodeEvent)
 	RegRpcEventFun(s.GetName())
 }
 
-func (s *Service) UnRegNodeConnListener() {
-	s.UnRegEventReceiverFunc(event.Sys_Event_Node_Conn_Event,s.GetEventHandler())
-	UnRegRpcEventFun(s.GetName())
-}
-
-func (s *Service) RegNatsConnListener(natsConnListener rpc.INatsConnListener) {
-	s.natsConnListener = natsConnListener
-	s.RegEventReceiverFunc(event.Sys_Event_Nats_Conn_Event,s.GetEventHandler(),s.OnNatsConnEvent)
-	RegRpcEventFun(s.GetName())
-}
-
-func (s *Service) UnRegNatsConnListener() {
-	s.UnRegEventReceiverFunc(event.Sys_Event_Nats_Conn_Event,s.GetEventHandler())
+func (s *Service) UnRegRpcListener(rpcLister rpc.INodeListener) {
+	s.UnRegEventReceiverFunc(event.Sys_Event_Node_Event,s.GetEventHandler())
 	UnRegRpcEventFun(s.GetName())
 }
 
@@ -371,7 +346,7 @@ func (s *Service) RegDiscoverListener(discoveryServiceListener rpc.IDiscoverySer
 	RegDiscoveryServiceEventFun(s.GetName())
 }
 
-func (s *Service) UnRegDiscoverListener() {
+func (s *Service) UnRegDiscoverListener(rpcLister rpc.INodeListener) {
 	s.UnRegEventReceiverFunc(event.Sys_Event_DiscoverService,s.GetEventHandler())
 	UnRegDiscoveryServiceEventFun(s.GetName())
 }
@@ -435,4 +410,4 @@ func (s *Service) SetGoRoutineNum(goroutineNum int32) bool {
 }
 
 func (s *Service) OnRetire(){
-}
+}

service/servicemgr.go

@@ -1,9 +1,6 @@
 package service
 
-import (
-	"github.com/duanhf2012/origin/v2/log"
-	"os"
-)
+import "errors"
 
 //本地所有的service
 var mapServiceName map[string]IService
@@ -26,8 +23,8 @@ func Init() {
 	for _,s := range setupServiceList {
 		err := s.OnInit()
 		if err != nil {
-			log.SError("Failed to initialize "+s.GetName()+" service:"+err.Error())
-			os.Exit(1)
+			errs := errors.New("Failed to initialize "+s.GetName()+" service:"+err.Error())
+			panic(errs)
 		}
 	}
 }

sysmodule/httpclientmodule/httpclientpoolmodule.go

@@ -10,7 +10,7 @@ import (
 	"net/url"
 	"time"
 
-	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/service"
 )
 
 type HttpClientModule struct {

sysmodule/mongomodule/mongomodule.go

@@ -1,7 +1,7 @@
 package mongomodule
 
 import (
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"gopkg.in/mgo.v2"
 	"gopkg.in/mgo.v2/bson"
 	"sync"

sysmodule/mysqlmodule/mysqlmodule.go

@@ -4,7 +4,7 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"net/url"
 	"reflect"
 	"strconv"
@@ -12,7 +12,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/service"
 	_ "github.com/go-sql-driver/mysql"
 )
 

sysmodule/redismodule/redismodule.go

@@ -5,11 +5,11 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"strconv"
 	"time"
 
-	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/service"
 	"github.com/gomodule/redigo/redis"
 )
 

sysservice/httpservice/httpservice.go

@@ -2,10 +2,10 @@ package httpservice
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/event"
-	"github.com/duanhf2012/origin/v2/network"
-	"github.com/duanhf2012/origin/v2/service"
-	"github.com/duanhf2012/origin/v2/util/uuid"
+	"github.com/duanhf2012/origin/event"
+	"github.com/duanhf2012/origin/network"
+	"github.com/duanhf2012/origin/service"
+	"github.com/duanhf2012/origin/util/uuid"
 	jsoniter "github.com/json-iterator/go"
 	"io"
 	"net/http"

sysservice/messagequeueservice/CustomerSubscriber.go

@@ -3,10 +3,10 @@ package messagequeueservice
 import (
 	"errors"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/cluster"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/rpc"
-	"github.com/duanhf2012/origin/v2/util/coroutine"
+	"github.com/duanhf2012/origin/cluster"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/rpc"
+	"github.com/duanhf2012/origin/util/coroutine"
 	"strings"
 	"sync/atomic"
 	"time"

sysservice/messagequeueservice/MemoryQueue.go

@@ -1,7 +1,7 @@
 package messagequeueservice
 
 import (
-	"github.com/duanhf2012/origin/v2/util/algorithms"
+	"github.com/duanhf2012/origin/util/algorithms"
 	"sync"
 )
 

sysservice/messagequeueservice/MessageQueueService.go

@@ -3,9 +3,9 @@ package messagequeueservice
 import (
 	"errors"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/service"
-	"github.com/duanhf2012/origin/v2/rpc"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/service"
+	"github.com/duanhf2012/origin/rpc"
 	"sync"
 )
 

sysservice/messagequeueservice/MongoPersist.go

@@ -3,9 +3,9 @@ package messagequeueservice
 import (
 	"errors"
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/service"
-	"github.com/duanhf2012/origin/v2/sysmodule/mongodbmodule"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/service"
+	"github.com/duanhf2012/origin/sysmodule/mongodbmodule"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo/options"
 	"time"

sysservice/messagequeueservice/Subscriber.go

@@ -1,8 +1,8 @@
 package messagequeueservice
 
 import (
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/rpc"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/rpc"
 
 	"sync"
 )

sysservice/messagequeueservice/TopicRoom.go

@@ -2,8 +2,8 @@ package messagequeueservice
 
 import (
 	"errors"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/util/coroutine"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/util/coroutine"
 	"sync"
 	"sync/atomic"
 	"time"

sysservice/rankservice/MongodbPersist.go

@@ -2,10 +2,10 @@ package rankservice
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/rpc"
-	"github.com/duanhf2012/origin/v2/service"
-	"github.com/duanhf2012/origin/v2/sysmodule/mongodbmodule"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/rpc"
+	"github.com/duanhf2012/origin/service"
+	"github.com/duanhf2012/origin/sysmodule/mongodbmodule"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo/options"
 	"runtime"
@@ -357,7 +357,7 @@ func (mp *MongoPersist) removeRankData(rankId uint64,keys []uint64) bool {
 
 func (mp *MongoPersist) upsertToDB(collectName string,rankData *RankData) error{
 	condition := bson.D{{"_id", rankData.Key}}
-	upsert := bson.M{"_id":rankData.Key,"RefreshTime": rankData.refreshTimestamp, "SortData": rankData.SortData, "Data": rankData.Data,"ExData":rankData.ExData}
+	upsert := bson.M{"_id":rankData.Key,"RefreshTime": rankData.RefreshTimestamp, "SortData": rankData.SortData, "Data": rankData.Data,"ExData":rankData.ExData}
 	update := bson.M{"$set": upsert}
 
 	s := mp.mongo.TakeSession()

sysservice/rankservice/RankData.go

@@ -1,9 +1,9 @@
 package rankservice
 
 import (
-	"github.com/duanhf2012/origin/v2/rpc"
-	"github.com/duanhf2012/origin/v2/util/algorithms/skip"
-	"github.com/duanhf2012/origin/v2/util/sync"
+	"github.com/duanhf2012/origin/rpc"
+	"github.com/duanhf2012/origin/util/algorithms/skip"
+	"github.com/duanhf2012/origin/util/sync"
 )
 
 var emptyRankData RankData
@@ -19,7 +19,7 @@ type RankData struct {
 	Data                 []byte
 	ExData               []int64
 
-	refreshTimestamp int64 //刷新时间
+	RefreshTimestamp int64 //刷新时间
 	//bRelease bool
 	ref         bool
 	compareFunc func(other skip.Comparator) int
@@ -39,7 +39,7 @@ func NewRankData(isDec bool, data *rpc.RankData,refreshTimestamp int64) *RankDat
 		ret.ExData = append(ret.ExData,d.InitValue+d.IncreaseValue)
 	}
 
-	ret.refreshTimestamp = refreshTimestamp
+	ret.RefreshTimestamp = refreshTimestamp
 
 	return ret
 }

sysservice/rankservice/RankDataExpire.go

@@ -2,7 +2,7 @@ package rankservice
 
 import (
 	"container/heap"
-	"github.com/duanhf2012/origin/v2/util/sync"
+	"github.com/duanhf2012/origin/util/sync"
 	"time"
 )
 

sysservice/rankservice/RankInterface.go

@@ -1,8 +1,8 @@
 package rankservice
 
 import (
-	"github.com/duanhf2012/origin/v2/service"
-	"github.com/duanhf2012/origin/v2/rpc"
+	"github.com/duanhf2012/origin/service"
+	"github.com/duanhf2012/origin/rpc"
 )
 
 type RankDataChangeType int8

sysservice/rankservice/RankService.go

@@ -4,9 +4,9 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/rpc"
-	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/rpc"
+	"github.com/duanhf2012/origin/service"
 )
 
 const PreMapRankSkipLen = 10

sysservice/rankservice/RankSkip.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/duanhf2012/origin/v2/rpc"
-	"github.com/duanhf2012/origin/v2/util/algorithms/skip"
+	"github.com/duanhf2012/origin/rpc"
+	"github.com/duanhf2012/origin/util/algorithms/skip"
 )
 
 type RankSkip struct {
@@ -250,7 +250,7 @@ func (rs *RankSkip) UpsetRank(upsetData *rpc.RankData, refreshTimestamp int64, f
 		//找到的情况对比排名数据是否有变化,无变化进行data更新,有变化则进行删除更新
 		if compareIsEqual(rankNode.SortData, upsetData.SortData) {
 			rankNode.Data = upsetData.GetData()
-			rankNode.refreshTimestamp = refreshTimestamp
+			rankNode.RefreshTimestamp = refreshTimestamp
 
 			if fromLoad == false {
 				rs.rankModule.OnChangeRankData(rs, rankNode)

sysservice/tcpservice/tcpservice.go

@@ -2,17 +2,17 @@ package tcpservice
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/event"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/network"
-	"github.com/duanhf2012/origin/v2/network/processor"
-	"github.com/duanhf2012/origin/v2/service"
-	"github.com/duanhf2012/origin/v2/util/bytespool"
+	"github.com/duanhf2012/origin/event"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/network"
+	"github.com/duanhf2012/origin/network/processor"
+	"github.com/duanhf2012/origin/node"
+	"github.com/duanhf2012/origin/service"
+	"github.com/duanhf2012/origin/util/bytespool"
 	"runtime"
 	"sync"
-	"github.com/google/uuid"
+	"sync/atomic"
 	"time"
-	"strings"
 )
 
 type TcpService struct {
@@ -20,7 +20,7 @@ type TcpService struct {
 	service.Service
 
 	mapClientLocker sync.RWMutex
-	mapClient       map[string] *Client
+	mapClient       map[uint64] *Client
 	process processor.IProcessor
 }
 
@@ -32,18 +32,32 @@ const(
 	TPT_UnknownPack TcpPackType = 3
 )
 
+const (
+	MaxNodeId = 1<<14 - 1  //最大值 16383
+	MaxSeed   = 1<<19 - 1  //最大值 524287
+	MaxTime   = 1<<31 - 1  //最大值 2147483647
+)
+
+var seed uint32
+
 type TcpPack struct {
 	Type         TcpPackType //0表示连接 1表示断开 2表示数据
-	ClientId     string
+	ClientId     uint64
 	Data         interface{}
 }
 
 type Client struct {
-	id string
+	id uint64
 	tcpConn *network.TCPConn
 	tcpService *TcpService
 }
 
+func (tcpService *TcpService) genId() uint64 {
+	newSeed := atomic.AddUint32(&seed,1) % MaxSeed
+	nowTime := uint64(time.Now().Unix())%MaxTime
+	return (uint64(node.GetNodeId()%MaxNodeId)<<50)|(nowTime<<19)|uint64(newSeed)
+}
+
 func (tcpService *TcpService) OnInit() error{
 	iConfig := tcpService.GetServiceCfg()
 	if iConfig == nil {
@@ -60,7 +74,6 @@ func (tcpService *TcpService) OnInit() error{
 	if ok == true {
 		tcpService.tcpServer.MaxConnNum = int(MaxConnNum.(float64))
 	}
-	
 	PendingWriteNum,ok := tcpCfg["PendingWriteNum"]
 	if ok == true {
 		tcpService.tcpServer.PendingWriteNum = int(PendingWriteNum.(float64))
@@ -92,7 +105,7 @@ func (tcpService *TcpService) OnInit() error{
 		tcpService.tcpServer.WriteDeadline = time.Second*time.Duration(writeDeadline.(float64))
 	}
 
-	tcpService.mapClient = make( map[string] *Client, tcpService.tcpServer.MaxConnNum)
+	tcpService.mapClient = make( map[uint64] *Client, tcpService.tcpServer.MaxConnNum)
 	tcpService.tcpServer.NewAgent = tcpService.NewClient
 	tcpService.tcpServer.Start()
 
@@ -122,16 +135,24 @@ func (tcpService *TcpService) NewClient(conn *network.TCPConn) network.Agent {
 	tcpService.mapClientLocker.Lock()
 	defer tcpService.mapClientLocker.Unlock()
 
-	uuId,_ := uuid.NewUUID()
-	clientId := strings.ReplaceAll(uuId.String(), "-", "")
-	pClient := &Client{tcpConn: conn, id: clientId}
-	pClient.tcpService = tcpService
-	tcpService.mapClient[clientId] = pClient
+	for {
+		clientId := tcpService.genId()
+		_,ok := tcpService.mapClient[clientId]
+		if ok == true {
+			continue
+		}
 
-	return pClient
+		pClient := &Client{tcpConn:conn, id:clientId}
+		pClient.tcpService = tcpService
+		tcpService.mapClient[clientId] = pClient
+
+		return pClient
+	}
+
+	return nil
 }
 
-func (slf *Client) GetId() string {
+func (slf *Client) GetId() uint64 {
 	return slf.id
 }
 
@@ -154,7 +175,7 @@ func (slf *Client) Run() {
 		slf.tcpConn.SetReadDeadline(slf.tcpService.tcpServer.ReadDeadline)
 		bytes,err := slf.tcpConn.ReadMsg()
 		if err != nil {
-			log.Debug("read client failed",log.ErrorAttr("error",err),log.String("clientId",slf.id))
+			log.Debug("read client failed",log.ErrorAttr("error",err),log.Uint64("clientId",slf.id))
 			break
 		}
 		data,err:=slf.tcpService.process.Unmarshal(slf.id,bytes)
@@ -174,7 +195,7 @@ func (slf *Client) OnClose(){
 	delete (slf.tcpService.mapClient,slf.GetId())
 }
 
-func (tcpService *TcpService) SendMsg(clientId string,msg interface{}) error{
+func (tcpService *TcpService) SendMsg(clientId uint64,msg interface{}) error{
 	tcpService.mapClientLocker.Lock()
 	client,ok := tcpService.mapClient[clientId]
 	if ok == false{
@@ -190,7 +211,7 @@ func (tcpService *TcpService) SendMsg(clientId string,msg interface{}) error{
 	return client.tcpConn.WriteMsg(bytes)
 }
 
-func (tcpService *TcpService) Close(clientId string) {
+func (tcpService *TcpService) Close(clientId uint64) {
 	tcpService.mapClientLocker.Lock()
 	defer tcpService.mapClientLocker.Unlock()
 
@@ -206,7 +227,7 @@ func (tcpService *TcpService) Close(clientId string) {
 	return
 }
 
-func (tcpService *TcpService) GetClientIp(clientid string) string{
+func (tcpService *TcpService) GetClientIp(clientid uint64) string{
 	tcpService.mapClientLocker.Lock()
 	defer tcpService.mapClientLocker.Unlock()
 	pClient,ok := tcpService.mapClient[clientid]
@@ -218,7 +239,7 @@ func (tcpService *TcpService) GetClientIp(clientid string) string{
 }
 
 
-func (tcpService *TcpService) SendRawMsg(clientId string,msg []byte) error{
+func (tcpService *TcpService) SendRawMsg(clientId uint64,msg []byte) error{
 	tcpService.mapClientLocker.Lock()
 	client,ok := tcpService.mapClient[clientId]
 	if ok == false{
@@ -229,7 +250,7 @@ func (tcpService *TcpService) SendRawMsg(clientId string,msg []byte) error{
 	return client.tcpConn.WriteMsg(msg)
 }
 
-func (tcpService *TcpService) SendRawData(clientId string,data []byte) error{
+func (tcpService *TcpService) SendRawData(clientId uint64,data []byte) error{
 	tcpService.mapClientLocker.Lock()
 	client,ok := tcpService.mapClient[clientId]
 	if ok == false{

sysservice/wsservice/wsservice.go

@@ -2,25 +2,32 @@ package wsservice
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/event"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/network"
-	"github.com/duanhf2012/origin/v2/network/processor"
-	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/event"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/network"
+	"github.com/duanhf2012/origin/network/processor"
+	"github.com/duanhf2012/origin/service"
+	"github.com/duanhf2012/origin/node"
 	"sync"
-	"github.com/google/uuid"
-	"strings"
+	"sync/atomic"
+	"time"
 )
 
+
+
 type WSService struct {
 	service.Service
 	wsServer network.WSServer
 
 	mapClientLocker sync.RWMutex
-	mapClient       map[string] *WSClient
+	mapClient       map[uint64] *WSClient
 	process         processor.IProcessor
+
+
 }
 
+var seed uint32
+
 type WSPackType int8
 const(
 	WPT_Connected WSPackType = 0
@@ -33,8 +40,14 @@ const Default_WS_MaxConnNum = 3000
 const Default_WS_PendingWriteNum = 10000
 const Default_WS_MaxMsgLen = 65535
 
+const (
+	MaxNodeId = 1<<14 - 1  //最大值 16383
+	MaxSeed   = 1<<19 - 1  //最大值 524287
+	MaxTime   = 1<<31 - 1  //最大值 2147483647
+)
+
 type WSClient struct {
-	id string
+	id uint64
 	wsConn *network.WSConn
 	wsService *WSService
 }
@@ -42,7 +55,7 @@ type WSClient struct {
 type WSPack struct {
 	Type         WSPackType //0表示连接 1表示断开 2表示数据
 	MsgProcessor processor.IProcessor
-	ClientId     string
+	ClientId     uint64
 	Data         interface{}
 }
 
@@ -66,7 +79,6 @@ func (ws *WSService) OnInit() error{
 	if ok == true {
 		ws.wsServer.MaxConnNum = int(MaxConnNum.(float64))
 	}
-
 	PendingWriteNum,ok := wsCfg["PendingWriteNum"]
 	if ok == true {
 		ws.wsServer.PendingWriteNum = int(PendingWriteNum.(float64))
@@ -77,7 +89,7 @@ func (ws *WSService) OnInit() error{
 		ws.wsServer.MaxMsgLen = uint32(MaxMsgLen.(float64))
 	}
 
-	ws.mapClient = make( map[string] *WSClient, ws.wsServer.MaxConnNum)
+	ws.mapClient = make( map[uint64] *WSClient, ws.wsServer.MaxConnNum)
 	ws.wsServer.NewAgent = ws.NewWSClient
 	ws.wsServer.Start()
 	return nil
@@ -106,21 +118,37 @@ func (ws *WSService) SetProcessor(process processor.IProcessor,handler event.IEv
 	ws.RegEventReceiverFunc(event.Sys_Event_WebSocket,handler, ws.WSEventHandler)
 }
 
+func (ws *WSService) genId() uint64 {
+	if node.GetNodeId()>MaxNodeId{
+		panic("nodeId exceeds the maximum!")
+	}
+
+	newSeed := atomic.AddUint32(&seed,1) % MaxSeed
+	nowTime := uint64(time.Now().Unix())%MaxTime
+	return (uint64(node.GetNodeId())<<50)|(nowTime<<19)|uint64(newSeed)
+}
+
 func (ws *WSService) NewWSClient(conn *network.WSConn) network.Agent {
 	ws.mapClientLocker.Lock()
 	defer ws.mapClientLocker.Unlock()
 
-	uuId, _ := uuid.NewUUID()
-	clientId := strings.ReplaceAll(uuId.String(), "-", "")
-	pClient := &WSClient{wsConn: conn, id: clientId}
-	pClient.wsService = ws
-	ws.mapClient[clientId] = pClient
-	return pClient
+	for {
+		clientId := ws.genId()
+		_,ok := ws.mapClient[clientId]
+		if ok == true {
+			continue
+		}
+
+		pClient := &WSClient{wsConn:conn, id: clientId}
+		pClient.wsService = ws
+		ws.mapClient[clientId] = pClient
+		return pClient
+	}
 
 	return nil
 }
 
-func (slf *WSClient) GetId() string {
+func (slf *WSClient) GetId() uint64 {
 	return slf.id
 }
 
@@ -148,7 +176,7 @@ func (slf *WSClient) OnClose(){
 	delete (slf.wsService.mapClient,slf.GetId())
 }
 
-func (ws *WSService) SendMsg(clientid string,msg interface{}) error{
+func (ws *WSService) SendMsg(clientid uint64,msg interface{}) error{
 	ws.mapClientLocker.Lock()
 	client,ok := ws.mapClient[clientid]
 	if ok == false{
@@ -164,7 +192,7 @@ func (ws *WSService) SendMsg(clientid string,msg interface{}) error{
 	return client.wsConn.WriteMsg(bytes)
 }
 
-func (ws *WSService) Close(clientid string) {
+func (ws *WSService) Close(clientid uint64) {
 	ws.mapClientLocker.Lock()
 	defer ws.mapClientLocker.Unlock()
 

util/buildtime/build.go

@@ -1,12 +1,12 @@
 package buildtime
 
 /*
-//查询buildtime包中的位置，在github.com/duanhf2012/origin/v2/util/buildtime.BuildTime中
+//查询buildtime包中的位置，在github.com/duanhf2012/origin/util/buildtime.BuildTime中
 go tool nm ./originserver.exe |grep buildtime
 
 //编译传入编译时间信息
-go build -ldflags "-X 'github.com/duanhf2012/origin/v2/util/buildtime.BuildTime=20200101'"
-go build -ldflags "-X github.com/duanhf2012/origin/v2/util/buildtime.BuildTime=20200101 -X github.com/duanhf2012/origin/v2/util/buildtime.BuildTag=debug"
+go build -ldflags "-X 'github.com/duanhf2012/origin/util/buildtime.BuildTime=20200101'"
+go build -ldflags "-X github.com/duanhf2012/origin/util/buildtime.BuildTime=20200101 -X github.com/duanhf2012/origin/util/buildtime.BuildTag=debug"
 */
 var BuildTime string
 var BuildTag  string

util/coroutine/coroutine.go

@@ -2,7 +2,7 @@ package coroutine
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 	"reflect"
 	"runtime/debug"
 )

util/math/math.go

@@ -1,7 +1,7 @@
 package math
 
 import (
-	"github.com/duanhf2012/origin/v2/log"
+	"github.com/duanhf2012/origin/log"
 )
 
 type NumberType interface {

util/timer/timer.go

@@ -2,8 +2,8 @@ package timer
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/log"
-	"github.com/duanhf2012/origin/v2/util/sync"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/util/sync"
 	"reflect"
 	"runtime"
 	"time"

util/umap/mapEx.go

@@ -2,7 +2,7 @@ package umap
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/v2/util/hash"
+	"github.com/duanhf2012/origin/util/hash"
 	"sync"
 	"sync/atomic"
 )