新增websocket

sysservice/tcpservice.go

@@ -13,7 +13,6 @@ type TcpService struct {
 	tcpServer network.TCPServer
 	service.Service
 
-	tcpService      *TcpService
 	mapClientLocker sync.RWMutex
 	mapClient       map[uint64] *Client
 	initClientId    uint64

sysservice/wsservice.go

@@ -1,4 +1,182 @@
 package sysservice
 
+import (
+	"fmt"
+	"github.com/duanhf2012/origin/event"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/network"
+	"github.com/duanhf2012/origin/service"
+	"sync"
+)
+
+type WSService struct {
+	service.Service
+	wsServer network.WSServer
+
+	mapClientLocker sync.RWMutex
+	mapClient       map[uint64] *WSClient
+	initClientId    uint64
+	process         network.Processor
+}
+
+type WSPackType int8
+const(
+	WPT_Connected WSPackType = 0
+	WPT_DisConnected WSPackType = 1
+	WPT_Pack WSPackType = 2
+	WPT_UnknownPack WSPackType = 3
+)
+
+type WSPack struct {
+	Type WSPackType //0表示连接 1表示断开 2表示数据
+	MsgProcessor network.Processor
+	ClientId uint64
+	Data interface{}
+}
 
 
+const Default_WS_MaxConnNum = 3000
+const Default_WS_PendingWriteNum = 10000
+const Default_WS_MaxMsgLen = 65535
+
+
+func (slf *WSService) OnInit() error{
+	iConfig := slf.GetServiceCfg()
+	if iConfig == nil {
+		return fmt.Errorf("%s service config is error!",slf.GetName())
+	}
+	wsCfg := iConfig.(map[string]interface{})
+	addr,ok := wsCfg["ListenAddr"]
+	if ok == false {
+		return fmt.Errorf("%s service config is error!",slf.GetName())
+	}
+
+	slf.wsServer.Addr = addr.(string)
+	slf.wsServer.MaxConnNum = Default_WS_MaxConnNum
+	slf.wsServer.PendingWriteNum = Default_WS_PendingWriteNum
+	slf.wsServer.MaxMsgLen = Default_WS_MaxMsgLen
+	MaxConnNum,ok := wsCfg["MaxConnNum"]
+	if ok == true {
+		slf.wsServer.MaxConnNum = int(MaxConnNum.(float64))
+	}
+	PendingWriteNum,ok := wsCfg["PendingWriteNum"]
+	if ok == true {
+		slf.wsServer.PendingWriteNum = int(PendingWriteNum.(float64))
+	}
+
+	MaxMsgLen,ok := wsCfg["MaxMsgLen"]
+	if ok == true {
+		slf.wsServer.MaxMsgLen = uint32(MaxMsgLen.(float64))
+	}
+
+	slf.mapClient = make( map[uint64] *WSClient,slf.wsServer.MaxConnNum)
+	slf.wsServer.NewAgent =slf.NewWSClient
+	slf.wsServer.Start()
+	return nil
+}
+
+func (slf *WSService) WSEventHandler(ev *event.Event) {
+	pack := ev.Data.(*WSPack)
+	switch pack.Type {
+	case WPT_Connected:
+		pack.MsgProcessor.ConnectedRoute(pack.ClientId)
+	case WPT_DisConnected:
+		pack.MsgProcessor.DisConnectedRoute(pack.ClientId)
+	case WPT_UnknownPack:
+		pack.MsgProcessor.UnknownMsgRoute(pack.Data,pack.ClientId)
+	case WPT_Pack:
+		pack.MsgProcessor.MsgRoute(pack.Data, pack.ClientId)
+	}
+}
+
+func (slf *WSService) SetProcessor(process network.Processor,handler event.IEventHandler){
+	slf.process = process
+	slf.RegEventReciverFunc(event.Sys_Event_WebSocket,handler,slf.WSEventHandler)
+}
+
+func (slf *WSService) NewWSClient(conn *network.WSConn) network.Agent {
+	slf.mapClientLocker.Lock()
+	defer slf.mapClientLocker.Unlock()
+
+	for {
+		slf.initClientId+=1
+		_,ok := slf.mapClient[slf.initClientId]
+		if ok == true {
+			continue
+		}
+
+		pClient := &WSClient{wsConn:conn, id:slf.initClientId}
+		pClient.wsService = slf
+		slf.mapClient[slf.initClientId] = pClient
+		return pClient
+	}
+
+	return nil
+}
+
+type WSClient struct {
+	id uint64
+	wsConn *network.WSConn
+	wsService *WSService
+}
+
+func (slf *WSClient) GetId() uint64 {
+	return slf.id
+}
+
+func (slf *WSClient) Run() {
+	slf.wsService.NotifyEvent(&event.Event{Type:event.Sys_Event_WebSocket,Data:&WSPack{ClientId:slf.id,Type:WPT_Connected,MsgProcessor:slf.wsService.process}})
+	for{
+		bytes,err := slf.wsConn.ReadMsg()
+		if err != nil {
+			log.Debug("read client id %d is error:%+v",slf.id,err)
+			break
+		}
+		data,err:=slf.wsService.process.Unmarshal(bytes)
+		if err != nil {
+			slf.wsService.NotifyEvent(&event.Event{Type:event.Sys_Event_WebSocket,Data:&WSPack{ClientId:slf.id,Type:WPT_UnknownPack,Data:bytes,MsgProcessor:slf.wsService.process}})
+			continue
+		}
+		slf.wsService.NotifyEvent(&event.Event{Type:event.Sys_Event_WebSocket,Data:&WSPack{ClientId:slf.id,Type:WPT_Pack,Data:data,MsgProcessor:slf.wsService.process}})
+	}
+}
+
+func (slf *WSClient) OnClose(){
+	slf.wsService.NotifyEvent(&event.Event{Type:event.Sys_Event_WebSocket,Data:&WSPack{ClientId:slf.id,Type:WPT_DisConnected,MsgProcessor:slf.wsService.process}})
+	slf.wsService.mapClientLocker.Lock()
+	defer slf.wsService.mapClientLocker.Unlock()
+	delete (slf.wsService.mapClient,slf.GetId())
+}
+
+func (slf *WSService) SendMsg(clientid uint64,msg interface{}) error{
+	slf.mapClientLocker.Lock()
+	client,ok := slf.mapClient[clientid]
+	if ok == false{
+		slf.mapClientLocker.Unlock()
+		return fmt.Errorf("client %d is disconnect!",clientid)
+	}
+
+	slf.mapClientLocker.Unlock()
+	bytes,err := slf.process.Marshal(msg)
+	if err != nil {
+		return err
+	}
+	return client.wsConn.WriteMsg(bytes)
+}
+
+func (slf *WSService) Close(clientid uint64) {
+	slf.mapClientLocker.Lock()
+	defer slf.mapClientLocker.Unlock()
+
+	client,ok := slf.mapClient[clientid]
+	if ok == false{
+		return
+	}
+
+	if client.wsConn!=nil {
+		client.wsConn.Close()
+	}
+
+	return
+}
+