cgserver 7.8.2113 → 7.9.2113

package/src/Framework/SocketServer/ISocketServer.ts

@@ -0,0 +1,243 @@
+import { GMysqlMgr } from '../Database/MysqlManager';
+import { GRedisMgr } from '../Database/RedisManager';
+import { IClientWebSocket } from './IClientWebSocket';
+import * as ws from 'websocket';
+import { GLog } from './../Logic/Log';
+import * as fs from "fs";
+import * as http from "http";
+import * as https from "https";
+import { GMongoMgr } from '../Database/MongoManager';
+import { GMSSqlMgr } from '../Database/MSSqlManager';
+import { GEventTool } from '../Logic/EventTool';
+import { GServerCfg, IServerConfig } from '../Config/IServerConfig';
+import { GCgServer } from '../cgserver';
+import { BaseMsg } from './IWebSocket';
+
+export class ISocketServer
+{
+    protected _cfg:IServerConfig=null
+    //方便提示
+    get cfg()
+    {
+        return this._cfg
+    }
+    //服务器已被关闭
+    protected _is_closed=false
+    get isClosed()
+    {
+        return this._is_closed
+    }
+    get name()
+    {
+        return this._cfg.serverName
+    }
+    //监听websocket
+    private _listening_websocket:ws.server= null
+    get listeningWebSocket()
+    {
+        return this._listening_websocket
+    }
+    //来自于用户的链接
+    protected _ws_clients:{[socketid:number]:IClientWebSocket}={}
+    get listenPort()
+    {
+        return this._cfg.port
+    }
+    /**
+     * websocket can accepted protocol
+     */
+    protected _accepted_protocol=null
+    //服务器管理相关
+    /*
+        item=servername:class
+    */
+    protected _name_vs_class={}
+    registerWebSocketHandleClass(name:string,cls)
+    {
+        if(!name||name=="")
+        {
+            throw "registerWebSocketHandleClass name must be not null or empty!"
+        }
+        this._name_vs_class[name] = cls
+    }
+    constructor(cfg:IServerConfig)
+    {
+        this._cfg=cfg
+    }
+    removeServerWebSocketBySocketId(socketId:number)
+    {
+        this._ws_clients[socketId] = null
+        delete this._ws_clients[socketId]
+    }
+    async run()
+    {
+        GCgServer.addSocketServer(this)
+        await GMSSqlMgr.init()
+        await GMysqlMgr.init()
+        await GRedisMgr.init(GServerCfg.db?.redis)
+        await GMongoMgr.init(GServerCfg.db?.mongo)
+        this.initWebSocket()
+    }
+    stop()
+    {
+        this._is_closed=true
+        this._listening_websocket.closeAllConnections()
+    }
+    /*
+        把所有的客户端链接保存起来
+        方便统计，广播等
+    */
+    addClient(ws_client:IClientWebSocket)
+    {
+        this._ws_clients[ws_client.socketId] = ws_client
+    }
+    isOriginAllowed(origin)
+    {
+        return true
+    }
+    initWebSocket(wss?)
+    {
+        let server = null
+        if(wss)
+        {
+            console.log("wss:---")
+            let options =
+            {
+                key:fs.readFileSync("ssl/ssl2.key"),
+                cert: fs.readFileSync("ssl/ssl2.crt"),
+                //passphrase:'1234'//如果秘钥文件有密码的话，用这个属性设置密码
+            }
+            server = https.createServer(options,(request, response)=>
+            {
+                GLog.info((new Date()) + 'wss Received request for ' + request.url)
+                response.writeHead(404)
+                response.end()
+            })
+        }
+        else
+        {
+            server = http.createServer((request, response)=>
+            {
+                GLog.info((new Date()) + 'ws Received request for ' + request.url)
+                response.writeHead(404)
+                response.end()
+            })
+        }
+
+        server.listen(this._cfg.port, this.onListenning.bind(this))
+        
+        this._listening_websocket = new ws.server({
+            httpServer: server,
+            // You should not use autoAcceptConnections for production 
+            // applications, as it defeats all standard cross-origin protection 
+            // facilities built into the protocol and the browser.  You should 
+            // *always* verify the connection's origin and decide whether or not 
+            // to accept it. 
+            autoAcceptConnections: false
+        })
+        this._listening_websocket.on('request', this.onRequest.bind(this))
+        this._listening_websocket.on('close', this.onClose.bind(this))
+    }
+    onClose(connection: ws.connection, reason: number, desc: string)
+    {
+        
+    }
+    onListenning()
+    {
+        GEventTool.emit("socket_server_init_done")
+        let info = (new Date()) + "  Server "+ this.name +" is listening on port "+this._cfg.port
+        GLog.info(info)
+        console.log(info)
+    }
+    onRequest(req:ws.request)
+    {
+        if(this._is_closed)
+        {
+            return
+        }
+        let protocol = null
+        if(req.requestedProtocols.length>0)
+        {
+            protocol = req.requestedProtocols[0]
+        }
+        let allowed = this.isOriginAllowed(req.origin)
+        if (!allowed)
+        {
+            req.reject()
+            GLog.info(' Connection from origin ' + req.origin + ' rejected.')
+            return
+        }
+        try
+        {
+            let conn = req.accept(this._accepted_protocol, req.origin)
+            if(!conn)
+            {
+                GLog.info(' protocol reject')
+                return
+            }
+            GLog.info((new Date()) + ' Connection accepted.')
+            let server_name = this._getServerNameByCookies(req.cookies)
+            this.createWebSocketObjectByProtocol(server_name,conn)
+        }
+        catch(e)
+        {
+            GLog.info(' protocol reject')
+        }
+    }
+    createWebSocketObjectByProtocol(server_name:string,_ws:ws.connection):IClientWebSocket
+    {
+        server_name=server_name||"default"
+        let cls = this._name_vs_class[server_name]
+        if(!cls)
+        {
+            GLog.error("(createWebSocketObjectByProtocol in server("+this.name+"))no this websocket handle class="+server_name)
+            return null
+        }
+        let ws_server = <IClientWebSocket>(new cls(this))
+        this.addClient(ws_server)
+        ws_server.onConnect(_ws)
+        return ws_server
+    }
+    protected _getServerNameByCookies(cookies)
+    {
+        let server_name = ""
+        if(!cookies)
+        {
+            return server_name
+        }
+        for(let index in cookies)
+        {
+            let cookie = cookies[index]
+            if(cookie.name=="server")
+            {
+                server_name = cookie.value
+                break
+            }
+        }
+        return server_name
+    }
+    /**
+     * 广播消息
+     * @param msg 
+     */
+    broadCast(msg:BaseMsg)
+    {
+        for(var key in this._ws_clients)
+        {
+            let ws = this._ws_clients[key] as IClientWebSocket
+            ws.send(msg)
+        }
+    }
+    /**
+     * 获取任意客户端连接
+     * @returns 
+     */
+    getAnyWebSocket()
+    {
+        for(var key in this._ws_clients)
+        {
+            return this._ws_clients[key] as IClientWebSocket
+        }
+        return null
+    }
+}

package/src/Framework/SocketServer/IWebSocket.ts

@@ -0,0 +1,243 @@
+import { GLog } from '../Logic/Log';
+import { GProtoFactory } from './ProtoFilter/ProtoFactory';
+import { IProtoFilter,EProtoType } from "./ProtoFilter/IProtoFilter";
+import * as ws from 'websocket';
+import { core } from '../Core/Core';
+import * as _ from "underscore";
+import { GServerCfg } from '../Config/IServerConfig';
+import { GSyncQueueTool } from '../Logic/SyncQueueTool';
+
+export class BaseMsg
+{
+    cmd: string
+    errcode?: {id:number,des:string}
+    servertime=Date.now()
+    constructor(cmd:string,errcode?: {id:number,des:string})
+    {
+        this.cmd=cmd
+        this.errcode=errcode
+    }
+}
+export class IWebSocket
+{
+    /**
+     * 是否同步消息
+     * 默认为true
+     */
+    protected _is_sync_msg = true
+    get isSynMsg()
+    {
+        return this._is_sync_msg
+    }
+    protected _debug_msg:boolean=false
+    get debug_msg()
+    {
+        return this._debug_msg
+    }
+    set debug_msg(value)
+    {
+        this._debug_msg = value
+    }
+    protected _socket_id: number=0
+    get socketId():number
+    {
+        return this._socket_id
+    }
+    protected _tipKey:string=""
+    get tipKey()
+    {
+        return this._tipKey
+    }
+    protected _ws:ws.connection =null
+    protected _protoType:EProtoType=EProtoType.Json
+    protected _protoFilter:IProtoFilter=null
+    protected _protoPath=""
+    
+    protected _ip:string = null
+    get remoteHost()
+    {
+        if(!this._ip)
+        {
+            this._ip = this._ws.remoteAddress
+            this._ip = this._ip.substring(this._ip.lastIndexOf(":")+1)
+        }
+        return this._ip
+    }
+    get connected()
+    {
+        if (this._ws
+            &&this._ws.connected==true)
+        {
+            return true
+        }
+        return false
+    }
+    constructor(protoType=EProtoType.Json,protoPath="")
+    {
+        this._debug_msg = GServerCfg.debug_msg
+        this._socket_id = parseInt(_.uniqueId())
+        this._protoType=protoType
+        this._protoPath=protoPath
+    }
+    getNewMsg(cmd:string, errcode?:{id:number,des:string}):BaseMsg|any
+    {
+        let msg = new BaseMsg(cmd,errcode)
+        return msg
+    }
+    receive_heartbeat(jsonData)
+    {
+        this.send_heartbeat()
+    }
+    send_heartbeat()
+    {
+        let msg = this.getNewMsg("heartbeat")
+        this.send(msg)
+    }
+    onConnect(_ws:ws.connection)
+    {
+        this._ws = _ws
+        if(!this._protoFilter)
+        {
+            this._protoFilter = GProtoFactory.createFilter(this._protoType)
+            this._protoFilter.init(this._protoPath)
+        }
+        this._ws.on("message",this.onMessage.bind(this))
+        this._ws.on("error",this.onError.bind(this))
+        this._ws.on("close",this.onClose.bind(this))
+        this.onOpen()
+    }
+    onMessage(message:ws.Message)
+    {
+        try
+        {
+            let msg = this._onDecode(message)
+            if(this._is_sync_msg)
+            {
+                GSyncQueueTool.add(this._socket_id+"",this._onMessage,this,msg)
+            }
+            else
+            {
+                this._onMessage(msg)
+            }
+        }
+        catch (e)
+        {
+            GLog.error(this.tipKey+' Received Message Handle Error: ' + e)
+        }
+    }
+    protected _onDecode(message:ws.Message,...params)
+    {
+        let msg=null
+        if (message.type === 'utf8')
+        {
+            msg=this._protoFilter.decode(message.utf8Data,...params)
+        }
+        else if (message.type === 'binary')
+        {
+            msg=this._protoFilter.decode(message.binaryData,...params)
+        }
+        return msg
+    }
+    protected _onEncode(data,...params)
+    {
+        let msg = this._protoFilter.encode(data,...params)
+        return msg
+    }
+    /**
+     * 过滤消息，每个消息处理之前调用
+     * @param msg 
+     * @returns 
+     */
+    filterMsg(msg:BaseMsg)
+    {
+        if(!msg)
+        {
+            GLog.error({tipKey:this.tipKey,action:"receive",error:"no cmd",msg})
+            return false
+        }
+        if(this._debug_msg && msg.cmd!="heartbeat")
+        {
+            GLog.info({tipKey:this.tipKey,action:"receive",msg})
+        }
+        if (!msg.cmd)
+        {
+            GLog.error({tipKey:this.tipKey,action:"receive",error:"no cmd",msg})
+            return false
+        }
+        return true
+    }
+    protected async _onMessage(data)
+    {
+        let jsonData = data
+        let func:Function = this["receive_"+jsonData.cmd]
+        let ret = this.filterMsg(jsonData)
+        if(!ret)
+        {
+            return
+        }
+        else if (!func)
+        {
+            let otherfunc:Function=this["receive_other_all"]
+            if(otherfunc)
+            {
+                await core.safeCall(otherfunc,this,jsonData)
+            }
+            else
+            {
+                GLog.error(this.tipKey+' Received Message warning: no cmd handle,cmd=' + jsonData.cmd)
+            }
+        }
+        else
+        {
+            await core.safeCall(func,this,jsonData)
+        }
+    }
+    onOpen(e?)
+    {
+        
+    }
+    onError(e:Error)
+    {
+        
+    }
+    onClose(reasonCode:number, description:string)
+    {
+        GLog.info(this.tipKey+" onClose resonCode="+reasonCode+"  des="+description)
+    }
+    send(msg:BaseMsg)
+    {
+        if (!this.connected)
+        {
+            return
+        }
+        if (!msg)
+        {
+            GLog.error(this.tipKey+" Send Message warning:null data!")
+            return
+        }
+        if(this._debug_msg
+            &&msg.cmd!="heartbeat")
+        {
+            GLog.info({tipKey:this.tipKey,action:"send",msg})
+        }
+        let data = this._onEncode(msg)
+        this._ws.send(data)
+    }
+    close()
+    {
+        this._ws.close()
+    }
+    getServerNameFromCmd(cmd)
+    {
+        if(!cmd||!core.isString(cmd))
+        {
+            return null
+        }
+        let index = cmd.indexOf("_")
+        if(index<=0)
+        {
+            return null
+        }
+        return cmd.substring(0,index)
+    }
+}

package/src/Framework/SocketServer/ProtoFilter/GoogleProtoFilter.ts

@@ -0,0 +1,68 @@
+import { IProtoFilter } from './IProtoFilter';
+import { core } from '../../Core/Core';
+import { GLog } from '../../Logic/Log';
+import * as protobufjs from 'protobufjs';
+
+export class GoogleProtoFilter implements IProtoFilter
+{
+    protected _root:protobufjs.Root=new protobufjs.Root()
+    protected _inited=false
+    init(path?:string):boolean
+    {
+        if(this._inited)
+        {
+            return
+        }
+        this._inited=true
+        try
+        {
+            this._root.loadSync(path,{keepCase:true})
+        }
+        catch(e)
+        {
+            GLog.error(e)
+            return false
+        }
+        return true
+    }
+    encode(data,root:string)
+    { 
+        let msg={cmd:data.cmd}
+        msg[msg.cmd]=data
+        msg[msg.cmd].cmd=undefined
+        
+        msg["errcode"]=data.errcode
+        msg["tip"]=data.tip
+        data.errcode=undefined
+
+        delete data.errcode
+        delete msg[msg.cmd].cmd
+
+        let body = this._root.lookupType(root)
+        var errMsg = body.verify(msg)
+        if (errMsg)
+            throw Error(errMsg)
+        var msgBody = body.create(msg);
+        var bufferBody = body.encode(msgBody).finish();
+        return bufferBody
+    }
+    decode(data,root:string)
+    {
+        let body = this._root.lookupType(root)
+        if(!body)
+        {
+            GLog.info("proto body not in proto(!"+root+")")
+            return null
+        }
+        let msgBody = body.decode(data)
+        if(!msgBody)
+        {
+            GLog.info("proto body decode wrong!")
+            return null
+        }
+        let objBody = body.toObject(msgBody)
+        let obj = objBody[objBody.cmd]
+        obj.cmd=objBody.cmd
+        return obj
+    }
+}

package/src/Framework/SocketServer/ProtoFilter/IProtoFilter.ts

@@ -0,0 +1,11 @@
+export enum EProtoType
+{
+    Json=1,
+    GoogleProtoBuffer=2
+}
+export interface IProtoFilter
+{
+    init(path?:string):boolean
+    encode(data,...params)
+    decode(data,...params)
+}

package/src/Framework/SocketServer/ProtoFilter/JsonProtoFilter.ts

@@ -0,0 +1,34 @@
+import { IProtoFilter } from './IProtoFilter';
+import { core } from '../../Core/Core';
+import { GLog } from '../../Logic/Log';
+export class JsonProtoFilter implements IProtoFilter
+{
+    init(path?:string)
+    {
+        return true
+    }
+    encode(data)
+    {
+        if(!core.isString(data))
+        {
+            data = JSON.stringify(data) 
+        }
+        return data
+    }
+    decode(data)
+    {
+        try
+        {
+            if(core.isString(data))
+            {
+                data = JSON.parse(data)
+            }
+        }
+        catch(e)
+        {
+            GLog.error("decode json data Failed-----data="+data)
+            return
+        }
+        return data
+    }
+}

package/src/Framework/SocketServer/ProtoFilter/ProtoFactory.ts

@@ -0,0 +1,34 @@
+import { GoogleProtoFilter } from './GoogleProtoFilter';
+import { JsonProtoFilter } from './JsonProtoFilter';
+import { IProtoFilter } from './IProtoFilter';
+import { EProtoType } from "./IProtoFilter";
+
+export let GProtoFactory:ProtoFactory=null
+class ProtoFactory
+{
+    protected _filters=new Map<EProtoType,IProtoFilter>()
+    createFilter(type:EProtoType):IProtoFilter
+    {
+        let filter = this._filters.get(type)
+        if(filter)
+        {
+            return filter
+        }
+        switch(type)
+        {
+            case EProtoType.GoogleProtoBuffer:
+            {
+                filter = new GoogleProtoFilter()
+                break
+            }
+            default:
+            {
+                filter = new JsonProtoFilter()
+                break
+            }
+        }
+        this._filters.set(type,filter)
+        return filter
+    }
+}
+GProtoFactory=new ProtoFactory()