Ma/origin
1
0
Fork 0
mirror of https://github.com/duanhf2012/origin.git synced 2026-02-03 22:45:13 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

优化代码

Browse Source
This commit is contained in:
boyce
2020-10-29 20:45:33 +08:00
parent be792337fb
commit 3025eaebd5
7 changed files with 189 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
cluster/cluster.go
View File

@@ -9,9 +9,7 @@ import (
"sync"
)
var configdir = "./config/"
var configDir = "./config/"
type NodeInfo struct {
NodeId int
@@ -21,83 +19,77 @@ type NodeInfo struct {
}
type NodeRpcInfo struct {
nodeinfo NodeInfo
nodeInfo NodeInfo
client *rpc.Client
}
var cluster Cluster
type Cluster struct {
localNodeInfo NodeInfo //×
localServiceCfg map[string]interface{} //map[servicename]配置数据*
mapRpc map[int] NodeRpcInfo//nodeid
rpcServer rpc.Server
serviceDiscovery IServiceDiscovery //服务发现接口
mapIdNode map[int]NodeInfo //map[NodeId]NodeInfo
mapServiceNode map[string][]int //map[serviceName]NodeInfo
localNodeInfo NodeInfo
localServiceCfg map[string]interface{} //map[serviceName]配置数据*
mapRpc map[int] NodeRpcInfo //nodeId
serviceDiscovery IServiceDiscovery //服务发现接口
mapIdNode map[int]NodeInfo //map[NodeId]NodeInfo
mapServiceNode map[string][]int //map[serviceName]NodeInfo
locker sync.RWMutex
rpcServer rpc.Server
}
func SetConfigDir(cfgdir string){
configdir = cfgdir
func SetConfigDir(cfgDir string){
configDir = cfgDir
}
func SetServiceDiscovery(serviceDiscovery IServiceDiscovery) {
cluster.serviceDiscovery = serviceDiscovery
}
func (slf *Cluster) serviceDiscoveryDelNode (nodeId int){
slf.locker.Lock()
defer slf.locker.Unlock()
func (cls *Cluster) serviceDiscoveryDelNode (nodeId int){
cls.locker.Lock()
defer cls.locker.Unlock()
slf.delNode(nodeId)
cls.delNode(nodeId)
}
func (slf *Cluster) delNode(nodeId int){
func (cls *Cluster) delNode(nodeId int){
//删除rpc连接关系
rpc,ok := slf.mapRpc[nodeId]
rpc,ok := cls.mapRpc[nodeId]
if ok == true {
delete(slf.mapRpc,nodeId)
delete(cls.mapRpc,nodeId)
rpc.client.Close(false)
}
nodeInfo,ok := slf.mapIdNode[nodeId]
nodeInfo,ok := cls.mapIdNode[nodeId]
if ok == false {
return
}
for _,serviceName := range nodeInfo.ServiceList{
slf.delServiceNode(serviceName,nodeId)
cls.delServiceNode(serviceName,nodeId)
}
delete(slf.mapIdNode,nodeId)
delete(cls.mapIdNode,nodeId)
}
func (slf *Cluster) delServiceNode(serviceName string,nodeId int){
nodeList := slf.mapServiceNode[serviceName]
func (cls *Cluster) delServiceNode(serviceName string,nodeId int){
nodeList := cls.mapServiceNode[serviceName]
for idx,nId := range nodeList {
if nId == nodeId {
slf.mapServiceNode[serviceName] = append(nodeList[idx:],nodeList[idx+1:]...)
cls.mapServiceNode[serviceName] = append(nodeList[idx:],nodeList[idx+1:]...)
return
}
}
}
func (slf *Cluster) serviceDiscoverySetNodeInfo (nodeInfo *NodeInfo){
if nodeInfo.NodeId == slf.localNodeInfo.NodeId {
func (cls *Cluster) serviceDiscoverySetNodeInfo (nodeInfo *NodeInfo){
if nodeInfo.NodeId == cls.localNodeInfo.NodeId {
return
}
slf.locker.Lock()
defer slf.locker.Unlock()
cls.locker.Lock()
defer cls.locker.Unlock()
//先清理删除
slf.delNode(nodeInfo.NodeId)
cls.delNode(nodeInfo.NodeId)
//再重新组装
mapDuplicate := map[string]interface{}{} //预防重复数据
@@ -108,58 +100,58 @@ func (slf *Cluster) serviceDiscoverySetNodeInfo (nodeInfo *NodeInfo){
continue
}
slf.mapServiceNode[serviceName] = append(slf.mapServiceNode[serviceName],nodeInfo.NodeId)
cls.mapServiceNode[serviceName] = append(cls.mapServiceNode[serviceName],nodeInfo.NodeId)
}
slf.mapIdNode[nodeInfo.NodeId] = *nodeInfo
cls.mapIdNode[nodeInfo.NodeId] = *nodeInfo
rpcInfo := NodeRpcInfo{}
rpcInfo.nodeinfo = *nodeInfo
rpcInfo.nodeInfo = *nodeInfo
rpcInfo.client = &rpc.Client{}
rpcInfo.client.Connect(nodeInfo.ListenAddr)
slf.mapRpc[nodeInfo.NodeId] = rpcInfo
cls.mapRpc[nodeInfo.NodeId] = rpcInfo
}
func (slf *Cluster) buildLocalRpc(){
func (cls *Cluster) buildLocalRpc(){
rpcInfo := NodeRpcInfo{}
rpcInfo.nodeinfo = slf.localNodeInfo
rpcInfo.nodeInfo = cls.localNodeInfo
rpcInfo.client = &rpc.Client{}
rpcInfo.client.Connect("")
slf.mapRpc[slf.localNodeInfo.NodeId] = rpcInfo
cls.mapRpc[cls.localNodeInfo.NodeId] = rpcInfo
}
func (slf *Cluster) Init(localNodeId int) error{
slf.locker.Lock()
func (cls *Cluster) Init(localNodeId int) error{
cls.locker.Lock()
//1.处理服务发现接口
if slf.serviceDiscovery == nil {
slf.serviceDiscovery = &ConfigDiscovery{}
if cls.serviceDiscovery == nil {
cls.serviceDiscovery = &ConfigDiscovery{}
}
//2.初始化配置
err := slf.InitCfg(localNodeId)
err := cls.InitCfg(localNodeId)
if err != nil {
slf.locker.Unlock()
cls.locker.Unlock()
return err
}
slf.rpcServer.Init(slf)
slf.buildLocalRpc()
cls.rpcServer.Init(cls)
cls.buildLocalRpc()
slf.serviceDiscovery.RegFunDelNode(slf.serviceDiscoveryDelNode)
slf.serviceDiscovery.RegFunSetNode(slf.serviceDiscoverySetNodeInfo)
slf.locker.Unlock()
cls.serviceDiscovery.RegFunDelNode(cls.serviceDiscoveryDelNode)
cls.serviceDiscovery.RegFunSetNode(cls.serviceDiscoverySetNodeInfo)
cls.locker.Unlock()
err = slf.serviceDiscovery.Init(localNodeId)
err = cls.serviceDiscovery.Init(localNodeId)
if err != nil {
return err
}
return nil
}
func (slf *Cluster) FindRpcHandler(servicename string) rpc.IRpcHandler {
pService := service.GetService(servicename)
func (cls *Cluster) FindRpcHandler(serviceName string) rpc.IRpcHandler {
pService := service.GetService(serviceName)
if pService == nil {
return nil
}
@@ -167,22 +159,22 @@ func (slf *Cluster) FindRpcHandler(servicename string) rpc.IRpcHandler {
return pService.GetRpcHandler()
}
func (slf *Cluster) Start() {
slf.rpcServer.Start(slf.localNodeInfo.ListenAddr)
func (cls *Cluster) Start() {
cls.rpcServer.Start(cls.localNodeInfo.ListenAddr)
}
func (slf *Cluster) Stop() {
slf.serviceDiscovery.OnNodeStop()
func (cls *Cluster) Stop() {
cls.serviceDiscovery.OnNodeStop()
}
func GetCluster() *Cluster{
return &cluster
}
func (slf *Cluster) GetRpcClient(nodeid int) *rpc.Client {
slf.locker.RLock()
defer slf.locker.RUnlock()
c,ok := slf.mapRpc[nodeid]
func (cls *Cluster) GetRpcClient(nodeId int) *rpc.Client {
cls.locker.RLock()
defer cls.locker.RUnlock()
c,ok := cls.mapRpc[nodeId]
if ok == false {
return nil
}
@@ -205,7 +197,7 @@ func GetRpcClient(nodeId int,serviceMethod string,clientList *[]*rpc.Client) err
return fmt.Errorf("servicemethod param %s is error!",serviceMethod)
}
//1.找到对应的rpcnodeid
//1.找到对应的rpcNodeid
GetCluster().GetNodeIdByService(serviceAndMethod[0],clientList)
return nil
}
@@ -214,7 +206,7 @@ func GetRpcServer() *rpc.Server{
return &cluster.rpcServer
}
func (slf *Cluster) IsNodeConnected (nodeId int) bool {
pClient := slf.GetRpcClient(nodeId)
func (cls *Cluster) IsNodeConnected (nodeId int) bool {
pClient := cls.GetRpcClient(nodeId)
return pClient!=nil && pClient.IsConnected()
}

18
cluster/configdiscovery.go
View File

@@ -7,8 +7,8 @@ type ConfigDiscovery struct {
localNodeId int
}
func (slf *ConfigDiscovery) Init(localNodeId int) error{
slf.localNodeId = localNodeId
func (discovery *ConfigDiscovery) Init(localNodeId int) error{
discovery.localNodeId = localNodeId
//解析本地其他服务配置
nodeInfoList,err := GetCluster().readLocalClusterConfig(0)
@@ -20,21 +20,19 @@ func (slf *ConfigDiscovery) Init(localNodeId int) error{
if nodeInfo.NodeId == localNodeId {
continue
}
slf.funSetService(&nodeInfo)
discovery.funSetService(&nodeInfo)
}
return nil
}
func (slf *ConfigDiscovery) OnNodeStop(){
func (discovery *ConfigDiscovery) OnNodeStop(){
}
func (slf *ConfigDiscovery) RegFunDelNode(funDelNode FunDelNode){
slf.funDelService = funDelNode
func (discovery *ConfigDiscovery) RegFunDelNode(funDelNode FunDelNode){
discovery.funDelService = funDelNode
}
func (slf *ConfigDiscovery) RegFunSetNode(funSetNodeInfo FunSetNodeInfo){
slf.funSetService = funSetNodeInfo
func (discovery *ConfigDiscovery) RegFunSetNode(funSetNodeInfo FunSetNodeInfo){
discovery.funSetService = funSetNodeInfo
}

81
cluster/parsecfg.go
View File

@@ -14,8 +14,7 @@ type NodeInfoList struct {
NodeList []NodeInfo
}
func (slf *Cluster) ReadClusterConfig(filepath string) (*NodeInfoList,error) {
func (cls *Cluster) ReadClusterConfig(filepath string) (*NodeInfoList,error) {
c := &NodeInfoList{}
d, err := ioutil.ReadFile(filepath)
if err != nil {
@@ -29,9 +28,7 @@ func (slf *Cluster) ReadClusterConfig(filepath string) (*NodeInfoList,error) {
return c,nil
}
func (slf *Cluster) readServiceConfig(filepath string) (map[string]interface{},map[int]map[string]interface{},error) {
func (cls *Cluster) readServiceConfig(filepath string) (map[string]interface{},map[int]map[string]interface{},error) {
c := map[string]interface{}{}
//读取配置
d, err := ioutil.ReadFile(filepath)
@@ -65,10 +62,9 @@ func (slf *Cluster) readServiceConfig(filepath string) (map[string]interface{},
return serviceConfig,mapNodeService,nil
}
func (slf *Cluster) readLocalClusterConfig(nodeId int) ([]NodeInfo,error) {
func (cls *Cluster) readLocalClusterConfig(nodeId int) ([]NodeInfo,error) {
var nodeInfoList [] NodeInfo
clusterCfgPath :=strings.TrimRight(configdir,"/") +"/cluster"
clusterCfgPath :=strings.TrimRight(configDir,"/") +"/cluster"
fileInfoList,err := ioutil.ReadDir(clusterCfgPath)
if err != nil {
return nil,fmt.Errorf("Read dir %s is fail :%+v",clusterCfgPath,err)
@@ -78,7 +74,7 @@ func (slf *Cluster) readLocalClusterConfig(nodeId int) ([]NodeInfo,error) {
for _,f := range fileInfoList{
if f.IsDir() == false {
filePath := strings.TrimRight(strings.TrimRight(clusterCfgPath,"/"),"\\")+"/"+f.Name()
localNodeInfoList,err := slf.ReadClusterConfig(filePath)
localNodeInfoList,err := cls.ReadClusterConfig(filePath)
if err != nil {
return nil,fmt.Errorf("read file path %s is error:%+v" ,filePath,err)
}
@@ -86,7 +82,6 @@ func (slf *Cluster) readLocalClusterConfig(nodeId int) ([]NodeInfo,error) {
for _,nodeInfo := range localNodeInfoList.NodeList {
if nodeInfo.NodeId == nodeId || nodeId == 0 {
nodeInfoList = append(nodeInfoList,nodeInfo)
//slf.localNodeInfo = nodeInfo
}
}
}
@@ -99,8 +94,8 @@ func (slf *Cluster) readLocalClusterConfig(nodeId int) ([]NodeInfo,error) {
return nodeInfoList,nil
}
func (slf *Cluster) readLocalService(localNodeId int) error {
clusterCfgPath :=strings.TrimRight(configdir,"/") +"/cluster"
func (cls *Cluster) readLocalService(localNodeId int) error {
clusterCfgPath :=strings.TrimRight(configDir,"/") +"/cluster"
fileInfoList,err := ioutil.ReadDir(clusterCfgPath)
if err != nil {
return fmt.Errorf("Read dir %s is fail :%+v",clusterCfgPath,err)
@@ -110,17 +105,17 @@ func (slf *Cluster) readLocalService(localNodeId int) error {
for _,f := range fileInfoList {
if f.IsDir() == false {
filePath := strings.TrimRight(strings.TrimRight(clusterCfgPath, "/"), "\\") + "/" + f.Name()
serviceConfig,mapNodeService,err := slf.readServiceConfig(filePath)
serviceConfig,mapNodeService,err := cls.readServiceConfig(filePath)
if err != nil {
continue
}
for _,s := range slf.localNodeInfo.ServiceList{
for _,s := range cls.localNodeInfo.ServiceList{
for{
//取公共服务配置
pubCfg,ok := serviceConfig[s]
if ok == true {
slf.localServiceCfg[s] = pubCfg
cls.localServiceCfg[s] = pubCfg
}
//如果结点也配置了该服务，则覆盖之
@@ -133,7 +128,7 @@ func (slf *Cluster) readLocalService(localNodeId int) error {
break
}
slf.localServiceCfg[s] = sCfg
cls.localServiceCfg[s] = sCfg
break
}
}
@@ -143,49 +138,48 @@ func (slf *Cluster) readLocalService(localNodeId int) error {
return nil
}
func (slf *Cluster) parseLocalCfg(){
slf.mapIdNode[slf.localNodeInfo.NodeId] = slf.localNodeInfo
func (cls *Cluster) parseLocalCfg(){
cls.mapIdNode[cls.localNodeInfo.NodeId] = cls.localNodeInfo
for _,sName := range slf.localNodeInfo.ServiceList{
slf.mapServiceNode[sName] = append(slf.mapServiceNode[sName],slf.localNodeInfo.NodeId)
for _,sName := range cls.localNodeInfo.ServiceList{
cls.mapServiceNode[sName] = append(cls.mapServiceNode[sName], cls.localNodeInfo.NodeId)
}
}
func (slf *Cluster) InitCfg(localNodeId int) error{
slf.localServiceCfg = map[string]interface{}{}
slf.mapRpc = map[int] NodeRpcInfo{}
slf.mapIdNode = map[int]NodeInfo{}
slf.mapServiceNode = map[string][]int{}
func (cls *Cluster) InitCfg(localNodeId int) error{
cls.localServiceCfg = map[string]interface{}{}
cls.mapRpc = map[int] NodeRpcInfo{}
cls.mapIdNode = map[int]NodeInfo{}
cls.mapServiceNode = map[string][]int{}
//加载本地结点的NodeList配置
nodeInfoList,err := slf.readLocalClusterConfig(localNodeId)
nodeInfoList,err := cls.readLocalClusterConfig(localNodeId)
if err != nil {
return err
}
slf.localNodeInfo = nodeInfoList[0]
cls.localNodeInfo = nodeInfoList[0]
//读取本地服务配置
err = slf.readLocalService(localNodeId)
err = cls.readLocalService(localNodeId)
if err != nil {
return err
}
//本地配置服务加到全局map信息中
slf.parseLocalCfg()
cls.parseLocalCfg()
return nil
}
func (slf *Cluster) IsConfigService(serviceName string) bool {
slf.locker.RLock()
defer slf.locker.RUnlock()
nodeList,ok := slf.mapServiceNode[serviceName]
func (cls *Cluster) IsConfigService(serviceName string) bool {
cls.locker.RLock()
defer cls.locker.RUnlock()
nodeList,ok := cls.mapServiceNode[serviceName]
if ok == false {
return false
}
for _,nodeId := range nodeList{
if slf.localNodeInfo.NodeId == nodeId {
if cls.localNodeInfo.NodeId == nodeId {
return true
}
}
@@ -193,10 +187,10 @@ func (slf *Cluster) IsConfigService(serviceName string) bool {
return false
}
func (slf *Cluster) GetNodeIdByService(servicename string,rpcClientList *[]*rpc.Client) {
slf.locker.RLock()
defer slf.locker.RUnlock()
nodeIdList,ok := slf.mapServiceNode[servicename]
func (cls *Cluster) GetNodeIdByService(serviceName string,rpcClientList *[]*rpc.Client) {
cls.locker.RLock()
defer cls.locker.RUnlock()
nodeIdList,ok := cls.mapServiceNode[serviceName]
if ok == true {
for _,nodeId := range nodeIdList {
pClient := GetCluster().GetRpcClient(nodeId)
@@ -209,9 +203,8 @@ func (slf *Cluster) GetNodeIdByService(servicename string,rpcClientList *[]*rpc.
}
}
func (slf *Cluster) getServiceCfg(servicename string) interface{}{
v,ok := slf.localServiceCfg[servicename]
func (cls *Cluster) getServiceCfg(serviceName string) interface{}{
v,ok := cls.localServiceCfg[serviceName]
if ok == false {
return nil
}
@@ -219,8 +212,8 @@ func (slf *Cluster) getServiceCfg(servicename string) interface{}{
return v
}
func (slf *Cluster) GetServiceCfg(serviceName string) interface{}{
serviceCfg,ok := slf.localServiceCfg[serviceName]
func (cls *Cluster) GetServiceCfg(serviceName string) interface{}{
serviceCfg,ok := cls.localServiceCfg[serviceName]
if ok == false {
return nil
}

1
cluster/servicediscovery.go
View File

@@ -8,7 +8,6 @@ type FunSetNodeInfo func(nodeInfo *NodeInfo)
type IServiceDiscovery interface {
Init(localNodeId int) error
OnNodeStop()
RegFunDelNode(funDelNode FunDelNode)
RegFunSetNode(funSetNodeInfo FunSetNodeInfo)
}

12
console/command.go
View File

@@ -9,6 +9,7 @@ import (
type valueType int
type CommandFunctionCB func(args interface{}) error
var commandList []*command
var programName string
const(
boolType valueType = iota
stringType valueType = iota
@@ -29,15 +30,12 @@ func (cmd *command) execute() error{
}else if cmd.valType == stringType {
return cmd.fn(cmd.strValue)
}else{
return fmt.Errorf("unknow command type!")
return fmt.Errorf("Unknow command type.")
}
return nil
}
var programName string
func Run(args []string) error {
flag.Parse()
programName = args[0]
@@ -57,7 +55,11 @@ func Run(args []string) error {
}
}
return startCmd.execute()
if startCmd != nil {
return startCmd.execute()
}
return fmt.Errorf("Command input parameter error,try `%s -help` for help",args[0])
}
func RegisterCommandBool(cmdName string, defaultValue bool, usage string,fn CommandFunctionCB){

149
event/event.go
View File

@@ -7,7 +7,7 @@ import (
"sync"
)
const Default_EventChannelLen = 10000
const DefaultEventChannelLen = 10000
//事件接受器
type EventCallBack func(event *Event)
@@ -22,7 +22,7 @@ type IEventHandler interface {
Init(processor IEventProcessor)
GetEventProcessor() IEventProcessor //获得事件
NotifyEvent(*Event)
Desctory()
Destroy()
//注册了事件
addRegInfo(eventType EventType,eventProcessor IEventProcessor)
removeRegInfo(eventType EventType,eventProcessor IEventProcessor)
@@ -77,135 +77,134 @@ func NewEventProcessor() IEventProcessor{
return &ep
}
func (slf *EventHandler) addRegInfo(eventType EventType,eventProcessor IEventProcessor){
slf.locker.Lock()
defer slf.locker.Unlock()
if slf.mapRegEvent == nil {
slf.mapRegEvent = map[EventType]map[IEventProcessor]interface{}{}
func (handler *EventHandler) addRegInfo(eventType EventType,eventProcessor IEventProcessor){
handler.locker.Lock()
defer handler.locker.Unlock()
if handler.mapRegEvent == nil {
handler.mapRegEvent = map[EventType]map[IEventProcessor]interface{}{}
}
if _,ok := slf.mapRegEvent[eventType] ;ok == false{
slf.mapRegEvent[eventType] = map[IEventProcessor]interface{}{}
if _,ok := handler.mapRegEvent[eventType] ;ok == false{
handler.mapRegEvent[eventType] = map[IEventProcessor]interface{}{}
}
slf.mapRegEvent[eventType][eventProcessor] = nil
handler.mapRegEvent[eventType][eventProcessor] = nil
}
func (slf *EventHandler) removeRegInfo(eventType EventType,eventProcessor IEventProcessor){
if _,ok :=slf.mapRegEvent[eventType];ok == true {
delete(slf.mapRegEvent[eventType],eventProcessor)
func (handler *EventHandler) removeRegInfo(eventType EventType,eventProcessor IEventProcessor){
if _,ok := handler.mapRegEvent[eventType];ok == true {
delete(handler.mapRegEvent[eventType],eventProcessor)
}
}
func (slf *EventHandler) GetEventProcessor() IEventProcessor{
return slf.eventProcessor
func (handler *EventHandler) GetEventProcessor() IEventProcessor{
return handler.eventProcessor
}
func (slf *EventHandler) NotifyEvent(ev *Event){
slf.GetEventProcessor().castEvent(ev)
func (handler *EventHandler) NotifyEvent(ev *Event){
handler.GetEventProcessor().castEvent(ev)
}
func (slf *EventHandler) Init(processor IEventProcessor){
slf.eventProcessor = processor
slf.mapRegEvent =map[EventType]map[IEventProcessor]interface{}{}
func (handler *EventHandler) Init(processor IEventProcessor){
handler.eventProcessor = processor
handler.mapRegEvent =map[EventType]map[IEventProcessor]interface{}{}
}
func (slf *EventProcessor) SetEventChannel(channelNum int) bool{
slf.locker.Lock()
defer slf.locker.Unlock()
if slf.eventChannel!=nil {
func (processor *EventProcessor) SetEventChannel(channelNum int) bool{
processor.locker.Lock()
defer processor.locker.Unlock()
if processor.eventChannel!=nil {
return false
}
if channelNum == 0 {
channelNum = Default_EventChannelLen
channelNum = DefaultEventChannelLen
}
slf.eventChannel = make(chan *Event,channelNum)
processor.eventChannel = make(chan *Event,channelNum)
return true
}
func (slf *EventProcessor) addBindEvent(eventType EventType,reciver IEventHandler,callback EventCallBack){
slf.locker.Lock()
defer slf.locker.Unlock()
func (processor *EventProcessor) addBindEvent(eventType EventType,reciver IEventHandler,callback EventCallBack){
processor.locker.Lock()
defer processor.locker.Unlock()
if _,ok := slf.mapBindHandlerEvent[eventType]; ok == false {
slf.mapBindHandlerEvent[eventType] = map[IEventHandler]EventCallBack{}
if _,ok := processor.mapBindHandlerEvent[eventType]; ok == false {
processor.mapBindHandlerEvent[eventType] = map[IEventHandler]EventCallBack{}
}
slf.mapBindHandlerEvent[eventType][reciver] = callback
processor.mapBindHandlerEvent[eventType][reciver] = callback
}
func (slf *EventProcessor) addListen(eventType EventType,reciver IEventHandler){
slf.locker.Lock()
defer slf.locker.Unlock()
func (processor *EventProcessor) addListen(eventType EventType,reciver IEventHandler){
processor.locker.Lock()
defer processor.locker.Unlock()
if _,ok :=slf.mapListenerEvent[eventType];ok == false{
slf.mapListenerEvent[eventType] = map[IEventProcessor]int{}
if _,ok := processor.mapListenerEvent[eventType];ok == false{
processor.mapListenerEvent[eventType] = map[IEventProcessor]int{}
}
slf.mapListenerEvent[eventType][reciver.GetEventProcessor()] += 1
processor.mapListenerEvent[eventType][reciver.GetEventProcessor()] += 1
}
func (slf *EventProcessor) removeBindEvent(eventType EventType,reciver IEventHandler){
slf.locker.Lock()
defer slf.locker.Unlock()
if _,ok := slf.mapBindHandlerEvent[eventType];ok == true{
delete(slf.mapBindHandlerEvent[eventType],reciver)
func (processor *EventProcessor) removeBindEvent(eventType EventType,reciver IEventHandler){
processor.locker.Lock()
defer processor.locker.Unlock()
if _,ok := processor.mapBindHandlerEvent[eventType];ok == true{
delete(processor.mapBindHandlerEvent[eventType],reciver)
}
}
func (slf *EventProcessor) removeListen(eventType EventType,reciver IEventHandler){
slf.locker.Lock()
defer slf.locker.Unlock()
if _,ok := slf.mapListenerEvent[eventType];ok == true{
slf.mapListenerEvent[eventType][reciver.GetEventProcessor()]-=1
if slf.mapListenerEvent[eventType][reciver.GetEventProcessor()] <= 0 {
delete(slf.mapListenerEvent[eventType],reciver.GetEventProcessor())
func (processor *EventProcessor) removeListen(eventType EventType,reciver IEventHandler){
processor.locker.Lock()
defer processor.locker.Unlock()
if _,ok := processor.mapListenerEvent[eventType];ok == true{
processor.mapListenerEvent[eventType][reciver.GetEventProcessor()]-=1
if processor.mapListenerEvent[eventType][reciver.GetEventProcessor()] <= 0 {
delete(processor.mapListenerEvent[eventType],reciver.GetEventProcessor())
}
}
}
func (slf *EventProcessor) RegEventReciverFunc(eventType EventType,reciver IEventHandler,callback EventCallBack){
func (processor *EventProcessor) RegEventReciverFunc(eventType EventType,reciver IEventHandler,callback EventCallBack){
//记录reciver自己注册过的事件
reciver.addRegInfo(eventType,slf)
reciver.addRegInfo(eventType, processor)
//记录当前所属IEventProcessor注册的回调
reciver.GetEventProcessor().addBindEvent(eventType,reciver,callback)
//将注册加入到监听中
slf.addListen(eventType,reciver)
processor.addListen(eventType,reciver)
}
func (slf *EventProcessor) UnRegEventReciverFun(eventType EventType,reciver IEventHandler) {
slf.removeListen(eventType,reciver)
func (processor *EventProcessor) UnRegEventReciverFun(eventType EventType,reciver IEventHandler) {
processor.removeListen(eventType,reciver)
reciver.GetEventProcessor().removeBindEvent(eventType,reciver)
reciver.removeRegInfo(eventType,slf)
reciver.removeRegInfo(eventType, processor)
}
func (slf *EventHandler) Desctory(){
for eventTyp,mapEventProcess := range slf.mapRegEvent {
func (handler *EventHandler) Destroy(){
for eventTyp,mapEventProcess := range handler.mapRegEvent {
if mapEventProcess == nil {
continue
}
//map[IEventProcessor]interface{}
for eventProcess,_ := range mapEventProcess {
eventProcess.UnRegEventReciverFun(eventTyp,slf)
eventProcess.UnRegEventReciverFun(eventTyp, handler)
}
}
}
func (slf *EventProcessor) GetEventChan() chan *Event{
slf.locker.Lock()
defer slf.locker.Unlock()
func (processor *EventProcessor) GetEventChan() chan *Event{
processor.locker.Lock()
defer processor.locker.Unlock()
if slf.eventChannel == nil {
slf.eventChannel =make(chan *Event,Default_EventChannelLen)
if processor.eventChannel == nil {
processor.eventChannel =make(chan *Event,DefaultEventChannelLen)
}
return slf.eventChannel
return processor.eventChannel
}
func (slf *EventProcessor) EventHandler(ev *Event) {
func (processor *EventProcessor) EventHandler(ev *Event) {
defer func() {
if r := recover(); r != nil {
buf := make([]byte, 4096)
@@ -215,7 +214,7 @@ func (slf *EventProcessor) EventHandler(ev *Event) {
}
}()
mapCallBack,ok := slf.mapBindHandlerEvent[ev.Type]
mapCallBack,ok := processor.mapBindHandlerEvent[ev.Type]
if ok == false {
return
}
@@ -227,28 +226,28 @@ func (slf *EventProcessor) EventHandler(ev *Event) {
func (slf *EventProcessor) pushEvent(event *Event){
if len(slf.eventChannel)>=cap(slf.eventChannel){
func (processor *EventProcessor) pushEvent(event *Event){
if len(processor.eventChannel)>=cap(processor.eventChannel){
log.Error("event process channel is full.")
return
}
slf.eventChannel<-event
processor.eventChannel<-event
}
func (slf *EventProcessor) castEvent(event *Event){
if slf.mapListenerEvent == nil{
func (processor *EventProcessor) castEvent(event *Event){
if processor.mapListenerEvent == nil{
log.Error("mapListenerEvent not init!")
return
}
processor,ok :=slf.mapListenerEvent[event.Type]
eventProcessor,ok := processor.mapListenerEvent[event.Type]
if ok == false || processor == nil{
log.Debug("event type %d not listen.",event.Type)
return
}
for proc,_ := range processor {
for proc,_ := range eventProcessor {
proc.pushEvent(event)
}
}

2
service/module.go
View File

@@ -124,7 +124,7 @@ func (slf *Module) ReleaseModule(moduleId int64){
slf.ReleaseModule(id)
}
pModule.GetEventHandler().Desctory()
pModule.GetEventHandler().Destroy()
pModule.self.OnRelease()
log.Debug("Release module %s.",slf.GetModuleName())
for pTimer,_ := range pModule.mapActiveTimer {