cgserver 7.10.2113 → 7.12.2113

package/src/Framework/SocketServer/ISocketServer.ts

@@ -1,243 +0,0 @@
-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

@@ -1,243 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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()