public bool Open(string strBrokerCfg)
{
if (strBrokerCfg.Length > 0)
{
m_strListenHost = strBrokerCfg;
}
m_acceptor = FFNet.Listen(m_strListenHost, new SocketMsgHandler(HandleMsg), new SocketBrokenHandler(HandleBroken));
if (m_acceptor != null)
{
FFLog.Trace(string.Format("FFBroker open....{0} ok", m_strListenHost));
}
else
{
FFLog.Trace(string.Format("FFBroker open....{0} failed", m_strListenHost));
}
return(true);
}
public void SaveLog()
{
if (m_name2data.Count == 0)
{
return;
}
try
{
string fileName = string.Format("./perf_{0:yyyy-MM-dd}.csv", System.DateTime.Now);
bool bExistFile = System.IO.File.Exists(fileName);
FileStream fs = new FileStream(fileName, FileMode.Append);
StreamWriter sw = new StreamWriter(fs);
if (!bExistFile)
{
sw.WriteLine("time, mod, max, min, per, rps, times");
}
string timefmt = string.Format("{0:yyyy-MM-dd HH:mm:ss}", System.DateTime.Now);
foreach (var kvp in m_name2data)
{
string nameMod = kvp.Key;
PerfData data = kvp.Value;
//! -------------------------- time, mod, max, min, per, rps, times
Int64 per = data.total / data.times;
Int64 rps = 0;
if (per > 0)
{
rps = 1000 * 1000 / per;
}
string logdata = string.Format("{0},{1},{2},{3},{4},{5},{6}", timefmt, nameMod, data.max, data.min, per, rps, data.times);
sw.WriteLine(logdata);
}
sw.Flush();
sw.Close();
fs.Close();
}
catch (System.Exception ex)
{
FFLog.Error("PerfMonitor.SaveLog:" + ex.Message);
}
m_name2data.Clear();
}
public static string InitClassByNames(string[] names)
{
string nspace = "ff";
var q = from t in System.Reflection.Assembly.GetExecutingAssembly().GetTypes()
where t.IsClass && t.Namespace == nspace
select t;
foreach (string name in names)
{
foreach (var t in q.ToList())
{
if (t.Name != name)
{
continue;
}
object[] paraNone = new object[] {};
System.Reflection.MethodInfo method = t.GetMethod("Instance");
if (method != null)
{
//Console.WriteLine(t.Name + ":" + method);
var ret = method.Invoke(null, paraNone);
System.Reflection.MethodInfo initMethod = t.GetMethod("Init");
if (initMethod != null)
{
object retB = initMethod.Invoke(ret, paraNone);
if (retB != null && retB is bool)
{
bool b = (bool)retB;
FFLog.Trace(string.Format("{0} init {1}", t.Name, b?"ok":"failed"));
if (!b)
{
return(t.Name);
}
}
}
}
break;
}
}
return("");
}
public void HandleAccepted(IAsyncResult ar)
{
try
{
Socket socket = (Socket)ar.AsyncState;
//方法参考：http://msdn.microsoft.com/zh-cn/library/system.net.sockets.socket.endreceive.aspx
if (socket != null)
{
var client = socket.EndAccept(ar);
IFFSocket ffsocket = new FFScoketAsync(m_funcRecv, m_funcBroken, client);
ffsocket.AsyncRecv();
m_oSocket.BeginAccept(new AsyncCallback(HandleAccepted), m_oSocket);
}
}
catch (Exception ex)
{
FFLog.Trace("scoket: handleAccepted Error " + ex.Message);
}
}
public bool Call <MSG_TYPE>(string strServiceName, MSG_TYPE msgData)
where MSG_TYPE : Thrift.Protocol.TBase, new()
{
if (!m_brokerData.Service2node_id.ContainsKey(strServiceName))
{
FFLog.Trace(string.Format("ffrpc.Call servervice:{0} not exist", strServiceName));
return(false);
}
BrokerRouteMsgReq reqMsg = new BrokerRouteMsgReq()
{
Callback_id = 0, Err_info = ""
};
reqMsg.Dest_node_id = m_brokerData.Service2node_id[strServiceName];
reqMsg.Dest_service_name = strServiceName;
reqMsg.Body = Util.Byte2String(FFNet.EncodeMsg(msgData));
reqMsg.Dest_msg_name = Type2Name(msgData);
SendToDestNode(reqMsg);
return(true);
}
public bool Listen(string ip, int port)
{
try{
if (ip == "*" || ip == "")
{
m_oSocket.Bind(new System.Net.IPEndPoint(System.Net.IPAddress.Any, port));
}
else
{
m_oSocket.Bind(new System.Net.IPEndPoint(System.Net.IPAddress.Parse(ip), port));
}
m_oSocket.Listen(2);
m_oSocket.BeginAccept(new AsyncCallback(HandleAccepted), m_oSocket);
}
catch (Exception ex)
{
FFLog.Trace("scoket: listen Error " + ex.Message);
return(false);
}
return(true);
}
public bool Open(string strBrokerHost, string strGateListenIpPort, int nGateIndex)
{
m_nGateIndex = nGateIndex;
m_strGateName = string.Format("gate#{0}", m_nGateIndex);
m_ffrpc = new FFRpc(m_strGateName);
m_ffrpc.Reg <GateChangeLogicNodeReq, EmptyMsgRet>(this.ChangeSessionLogic);
m_ffrpc.Reg <GateCloseSessionReq, EmptyMsgRet>(this.CloseSession);
m_ffrpc.Reg <GateRouteMsgToSessionReq, EmptyMsgRet>(this.RouteMsgToSession);
m_ffrpc.Reg <GateBroadcastMsgToSessionReq, EmptyMsgRet>(this.BroadcastMsgToSession);
m_acceptor = FFNet.Listen(strGateListenIpPort, new SocketMsgHandler(HandleMsg), new SocketBrokenHandler(HandleBroken));
if (m_acceptor != null)
{
FFLog.Trace(string.Format("FFGate open....{0} ok", strGateListenIpPort));
}
else
{
FFLog.Trace(string.Format("FFGate open....{0} failed", strGateListenIpPort));
}
return(true);
}
private void handleSendEnd(IAsyncResult ar)
{
var socket = ar.AsyncState as Socket;
try
{
if (socket == null || m_oSocket == null || !socket.Connected)
{
return;
}
socket.EndSend(ar);
}
catch (Exception ex)
{
FFLog.Warning("scoket: send Error1 " + ex.Message);
HandleClose();
return;
}
FFNet.GetTaskQueue().Post(() =>
{
try
{
if (m_oBuffSending.Count > 0)
{
m_oBuffSending.RemoveAt(0);
}
if (m_oBuffSending.Count > 0 && m_oSocket != null)
{
byte[] data = m_oBuffSending[0];
m_oSocket.BeginSend(data, 0, data.Length, 0, new AsyncCallback(handleSendEnd), m_oSocket);
}
}
catch (Exception ex)
{
FFLog.Trace("scoket: send Error " + ex.Message);
HandleClose();
}
});
}
public EmptyMsgRet OnRouteLogicMsgReq(RouteLogicMsgReq reqMsg)
{
Int64 nBeginUs = DateTime.Now.Ticks / 10;
int cmd = reqMsg.Cmd;
if ((cmd & 0x4000) != 0)
{
cmd &= ~(0x4000);
}
Int64 nSessionID = reqMsg.SessionId;
if (m_dictCmd2Func.ContainsKey(cmd) == false)
{
FFLog.Error(string.Format("worker cmd invalid! {0}", cmd));
return(RPC_NONE);
}
CmdRegInfo cmdRegInfo = m_dictCmd2Func[cmd];
cmdRegInfo.cmdHandler(nSessionID, reqMsg.Cmd, reqMsg.Body);
PerfMonitor.Instance().AddPerf(string.Format("cmd={0}", cmdRegInfo.cmdName), DateTime.Now.Ticks / 10 - nBeginUs);
return(RPC_NONE);
}
public EmptyMsgRet OnSessionOfflineReq(SessionOfflineReq reqMsg)
{
Int64 nSessionID = reqMsg.Session_id;
FFLog.Trace(string.Format("worker OnSessionOfflineReq! {0}", nSessionID));
if (m_dictRoles.ContainsKey(nSessionID) == false)
{
return(RPC_NONE);
}
Player player = getPlayerBySessionID(nSessionID);
m_dictRoles.Remove(nSessionID);
Pbmsg.LogoutRet retMsg = new Pbmsg.LogoutRet()
{
Id = player.getID(),
Name = player.strName,
};
BroadcastPlayerMsg <Pbmsg.LogoutRet>(Pbmsg.ServerCmdDef.SLogout, retMsg);
return(RPC_NONE);
}
private void RunAllTask()
{
List <FFTask> taskToRun = new List <FFTask>();
while (m_running)
{
m_mutex.WaitOne();
while (m_running && m_taskList.Count == 0)
{
m_mutex.ReleaseMutex();
m_event.WaitOne(100);
m_mutex.WaitOne();
}
foreach (FFTask task in m_taskList)
{
taskToRun.Add(task);
}
m_taskList.Clear();
m_mutex.ReleaseMutex();
foreach (FFTask task in taskToRun)
{
try
{
task();
}
catch (System.Exception ex)
{
FFLog.Trace("void RunAllTask exception:" + ex.Message);
continue;
}
finally
{
}
}
taskToRun.Clear();
}
}
public static void SendMsg(IFFSocket ffsocket, UInt16 cmdSrc, byte[] strData)
{
if (ffsocket.GetProtocolType() == "websocket")
{
byte[] cmddata = Util.String2Byte(string.Format("cmd:{0}\n", cmdSrc));
byte[] wsData = Util.MergeArray(cmddata, strData);
ffsocket.AsyncSend(wsData);
return;
}
int len = strData.Length;
len = System.Net.IPAddress.HostToNetworkOrder(len);
UInt16 cmd = (UInt16)System.Net.IPAddress.HostToNetworkOrder((Int16)cmdSrc);
byte[] lenArray = BitConverter.GetBytes(len);
byte[] cmdArray = BitConverter.GetBytes(cmd);
byte[] resArray = new byte[2] {
0, 0
};
byte[][] p = { lenArray, cmdArray, resArray, strData };
byte[] sendData = Util.MergeArray(p);
ffsocket.AsyncSend(sendData);
FFLog.Trace(string.Format("SendMsg cmd:{0},len:{1},len2:{2}", cmdSrc, strData.Length, sendData.Length));
}
//!切换worker
public EmptyMsgRet ChangeSessionLogic(GateChangeLogicNodeReq reqMsg)
{
FFLog.Trace(string.Format("FFGate ChangeSessionLogic....sessionid={0}", reqMsg.SessionId));
if (m_dictClients.ContainsKey(reqMsg.SessionId) == false)
{
return(m_msgEmpty);
}
ClientInfo cinfo = m_dictClients[reqMsg.SessionId];
SessionEnterWorkerReq msgEnter = new SessionEnterWorkerReq()
{
};
msgEnter.FromWorker = cinfo.strAllocWorker;
cinfo.strAllocWorker = reqMsg.AllocWorker;
msgEnter.SessionId = reqMsg.SessionId;
msgEnter.FromGate = m_strGateName;
msgEnter.SessionIp = cinfo.sockObj.GetIP();
msgEnter.ToWorker = reqMsg.AllocWorker;
msgEnter.ExtraData = reqMsg.ExtraData;
m_ffrpc.Call(reqMsg.AllocWorker, msgEnter);
return(m_msgEmpty);
}
public void HandleRecv(IFFSocket ffsocket, byte[] strData)
{
if (m_oWSProtocol.HandleRecv(strData))
{
if (ffsocket.GetProtocolType().Length == 0)
{
ffsocket.SetProtocolType("websocket");
}
foreach (var eachWaitSend in m_oWSProtocol.GetSendPkg())
{
ffsocket.AsyncSend(eachWaitSend, false);
}
m_oWSProtocol.ClearSendPkg();
foreach (var eachRecvPkg in m_oWSProtocol.GetRecvPkg())
{
if (eachRecvPkg.Length == 0)
{
continue;
}
UInt16 nCmd = 0;
byte[] dataBody = eachRecvPkg;
int nHeadEndIndex = -1;
if (eachRecvPkg[0] == 'c' || eachRecvPkg[0] == 'C')
{
ffsocket.SetProtocolType("websocket-text");
for (int i = 0; i < eachRecvPkg.Length; ++i)
{
if (eachRecvPkg[i] == '\n')
{
nHeadEndIndex = i;
break;
}
}
}
if (nHeadEndIndex > 0)
{
byte[] bytesHead = new byte[nHeadEndIndex];
dataBody = new byte[eachRecvPkg.Length - nHeadEndIndex - 1];
Array.Copy(eachRecvPkg, 0, bytesHead, 0, bytesHead.Length);
Array.Copy(eachRecvPkg, nHeadEndIndex + 1, dataBody, 0, dataBody.Length);
string[] strHeads = Util.Byte2String(bytesHead).Split(",");
string[] strCmds = strHeads[0].Split(":");
if (strCmds.Length == 2 && strCmds[1].Length > 0)
{
nCmd = Convert.ToUInt16(strCmds[1]);
}
}
else
{
if (eachRecvPkg.Length < 8)
{
continue;
}
size = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt32(eachRecvPkg, 0));
nCmd = (UInt16)System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(eachRecvPkg, 4));
flag = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(eachRecvPkg, 6));
dataBody = new byte[eachRecvPkg.Length - 8];
Array.Copy(eachRecvPkg, 8, dataBody, 0, dataBody.Length);
}
//FFLog.Trace(string.Format("cmd={0},data={1}", nCmd, dataBody.Length));
try
{
m_funcMsgHandler(ffsocket, nCmd, dataBody);
}
catch (Exception ex)
{
FFLog.Error("wsscoket.HandleRecv error:" + ex.Message);
}
}
m_oWSProtocol.ClearRecvPkg();
if (m_oWSProtocol.IsClose())
{
ffsocket.Close();
}
return;
}
Array.Copy(strData, 0, m_strRecvData, nLeftSize, strData.Length);
nLeftSize += strData.Length;
//Util.MergeArray(m_strRecvData, strData);
int nRead = 0;
while (true)
{
if (nLeftSize < nRead + 8)
{
Array.Copy(m_strRecvData, nRead, m_strRecvData, 0, nLeftSize - nRead);
break;
}
size = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt32(m_strRecvData, nRead + 0));
cmd = (UInt16)System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(m_strRecvData, nRead + 4));
flag = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(m_strRecvData, nRead + 6));
//FFLog.Trace(string.Format("HandleRecv cmd:{0},len:{1},recvlen:{2}", cmd, size, m_strRecvData.Length));
if (cmd == 0 || size == 0)
{
string st = "";
foreach (byte b in m_strRecvData)
{
st += b.ToString();
}
FFLog.Trace(st);
m_strRecvData = new byte[0];
string st2 = "";
foreach (byte b in strData)
{
st2 += b.ToString();
}
FFLog.Trace(st2);
break;
}
if (nLeftSize < nRead + 8 + size)
{
//FFLog.Error("scoket.HandleRecv 111111111111111111");
Array.Copy(m_strRecvData, nRead, m_strRecvData, 0, nLeftSize - nRead);
break;
}
byte[] msgBody = new byte[size];
Array.Copy(m_strRecvData, nRead + 8, msgBody, 0, size);
nRead += (8 + size);
// if (strData.Length == 8 + size)
// {
// m_strRecvData = new byte[0];
// }
// else{
// FFLog.Trace(string.Format("HandleRecv cmd:{0},len:{1},recvlen:{2},leftData:{3}", cmd, size, m_strRecvData.Length, leftData.Length));
// }
try
{
m_funcMsgHandler(ffsocket, cmd, msgBody);
}
catch (Exception ex)
{
FFLog.Error("scoket.HandleRecv error:" + ex.Message);
}
}
nLeftSize -= nRead;
}
public static void Main(string[] args)
{
#if linux
//if (args.Length >= 1 && (args[0] == "/daemon" || args[0] == "--daemon"))
for (int i = 0; i < args.Length; ++i)
{
if (args[i] != "/daemon" && args[i] != "--daemon")
{
continue;
}
FFLog.Trace(string.Format("config {0}", args[i]));
int pid = fork();
if (pid != 0)
{
exit(0);
}
setsid();
pid = fork();
if (pid != 0)
{
exit(0);
}
umask(022);
int max = open("/dev/null", 0);
for (var m = 0; m <= max; m++)
{
close(m);
}
//!read write error
int fd = open("/dev/null", 0);
dup(fd);
dup(fd);
var executablePath = Environment.GetCommandLineArgs()[0];
FFLog.Trace(string.Format("executablePath {0}", executablePath));
string[] argsNew = new string[args.Length + 1];//{"mono", executablePath};
int assignIndex = 0;
argsNew[assignIndex] = "mono";
assignIndex += 1;
argsNew[assignIndex] = executablePath;
assignIndex += 1;
for (int j = 0; j < args.Length; ++j)
{
if (i == j)
{
continue;
}
argsNew[assignIndex] = args[j];
assignIndex += 1;
}
execvp("mono", argsNew);
return;
}
#endif
string host = "tcp://127.0.0.1:43210";
FFBroker ffbroker = new FFBroker();
ffbroker.Open(host);
int nWorkerIndex = 0;
FFWorker worker = new FFWorker();
if (worker.Open(host, nWorkerIndex) == false)
{
FFLog.Trace("ffrpc open failed!");
}
//Console.ReadKey();
//ffrpc.GetTaskQueue().Post(() =>
//{
// SessionEnterWorkerReq reqMsg = new SessionEnterWorkerReq() { From_gate = "gate#0" };
// WorkerCallMsgReq reqWorkerCall = new WorkerCallMsgReq();
// //ffrpc.Call(strServiceName, reqMsg);
// reqMsg.From_gate = "gate#1";
// ffrpc.Call(strServiceName, reqWorkerCall, (SessionEnterWorkerReq retMsg) =>
// {
// FFLog.Trace(string.Format("ffrpc SessionEnterWorkerReq return!!!FromGate={0}", retMsg.From_gate));
// });
//});
FFGate ffGate = new FFGate();
if (ffGate.Open(host, "tcp://*:44000", 0) == false)
{
FFLog.Trace("ffGate open failed!");
}
//FFNet.Timerout(1000, Theout);
//FFNet.Timerout(2000, Theout);
// FFNet.Timerout(1000000, () =>
// {
// FFLog.Debug("AAAAAAAAAAAAAAA1");
// //ffbroker.Close();
// });
//FFLog.Trace(string.Format("main! {0}", System.Threading.Thread.CurrentThread.ManagedThreadId.ToString()));
bool bExit = false;
AppDomain.CurrentDomain.ProcessExit += (sender, arg) =>
{
FFLog.Trace("exist!!");
bExit = true;
};
Console.CancelKeyPress += (object sender, ConsoleCancelEventArgs e) => {
e.Cancel = true;
FFLog.Trace("exist3!!");
FFNet.Cleanup();
FFLog.Cleanup();
bExit = true;
};
while (!bExit)
{
System.Threading.Thread.Sleep(300);
}
FFLog.Trace("exist!!");
FFNet.Cleanup();
FFLog.Cleanup();
}
public static void Main(string[] args)
{
string host = "tcp://127.0.0.1:43210";
FFBroker ffbroker = new FFBroker();
ffbroker.Open(host);
int nWorkerIndex = 0;
FFWorker worker = new FFWorker();
if (worker.Open(host, nWorkerIndex) == false)
{
FFLog.Trace("ffrpc open failed!");
}
//Console.ReadKey();
//ffrpc.GetTaskQueue().Post(() =>
//{
// SessionEnterWorkerReq reqMsg = new SessionEnterWorkerReq() { From_gate = "gate#0" };
// WorkerCallMsgReq reqWorkerCall = new WorkerCallMsgReq();
// //ffrpc.Call(strServiceName, reqMsg);
// reqMsg.From_gate = "gate#1";
// ffrpc.Call(strServiceName, reqWorkerCall, (SessionEnterWorkerReq retMsg) =>
// {
// FFLog.Trace(string.Format("ffrpc SessionEnterWorkerReq return£¡£¡£¡FromGate={0}", retMsg.From_gate));
// });
//});
FFGate ffGate = new FFGate();
if (ffGate.Open(host, "tcp://*:44000", 0) == false)
{
FFLog.Trace("ffGate open failed!");
}
//FFNet.Timerout(1000, Theout);
//FFNet.Timerout(2000, Theout);
FFNet.Timerout(100000, () =>
{
FFLog.Debug("AAAAAAAAAAAAAAA1");
//ffbroker.Close();
});
FFLog.Trace(string.Format("main! {0}", System.Threading.Thread.CurrentThread.ManagedThreadId.ToString()));
AppDomain.CurrentDomain.ProcessExit += (sender, arg) =>
{
FFLog.Trace("exist!!");
};
Console.CancelKeyPress += (object sender, ConsoleCancelEventArgs e) => {
e.Cancel = true;
FFLog.Trace("exist3!!");
FFNet.Cleanup();
FFLog.Cleanup();
};
Console.ReadKey();
FFLog.Trace("exist!!");
FFNet.Cleanup();
FFLog.Cleanup();
}
public bool HandleRecv(byte[] strNewData)
{
if (statusWebSocketConnection == -1)
{
return(false);
}
cacheRecvData = MergeArray(cacheRecvData, strNewData);
if (dictParams.Count == 0)
{
string strRecvData = Byte2String(cacheRecvData);
if (strRecvData.Length < 3)
{
return(true);
}
if (strRecvData.Length >= 3 && strRecvData.StartsWith("GET") == false)
{
statusWebSocketConnection = -1;
return(false);
}
if (strRecvData.Contains("\r\n\r\n") == false)//!header data not end
{
return(true);
}
if (strRecvData.Contains("Upgrade: websocket") == false)
{
statusWebSocketConnection = -1;
return(false);
}
string[] strLines = strRecvData.Split("\r\n");
foreach (var line in strLines)
{
string[] strParams = line.Split(": ");
if (strParams.Length == 2)
{
dictParams[strParams[0]] = strParams[1];
}
else if (strParams.Length == 1 && strParams[0].Contains("GET"))
{
dictParams["PATH"] = strParams[0];
}
}
if (true == dictParams.ContainsKey("Sec-WebSocket-Key"))
{
string Sec_WebSocket_Key = dictParams["Sec-WebSocket-Key"];
string strGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
byte[] dataToHash = System.Text.Encoding.UTF8.GetBytes(Sec_WebSocket_Key + strGUID);
byte[] dataHashed = SHA1.Create().ComputeHash(dataToHash);
string strHashBase64 = Convert.ToBase64String(dataHashed);
string strSendData = string.Format("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: {0}\r\n\r\n", strHashBase64);
AddSendPkg(String2Byte(strSendData));
strRecvData = "";
cacheRecvData = new byte[0];
statusWebSocketConnection = 1;
return(true);
}
else if (true == dictParams.ContainsKey("Sec-WebSocket-Key1"))
{
string handshake = "HTTP/1.1 101 Web Socket Protocol Handshake\r\nUpgrade: WebSocket\r\nConnection: Upgrade\r\n";
string str_origin = dictParams["Origin"];
if (str_origin.Length == 0)
{
str_origin = "null";
}
handshake += "Sec-WebSocket-Origin: " + str_origin + "\r\n";
string str_host = dictParams["Host"];
if (str_host.Length > 0)
{
string[] tmp_path_arg = strLines[0].Split(" ");
string tmp_path = "/";
if (tmp_path_arg.Length >= 2)
{
tmp_path = tmp_path_arg[1];
}
handshake += "Sec-WebSocket-Location: ws://" + dictParams["Host"] + tmp_path + "\r\n\r\n";
}
UInt32 key1 = ComputeWebsokcetKeyVal(dictParams["Sec-WebSocket-Key1"]);
UInt32 key2 = ComputeWebsokcetKeyVal(dictParams["Sec-WebSocket-Key2"]);
string keyExt = strLines[strLines.Length - 1];
if (keyExt.Length < 8)
{
statusWebSocketConnection = -1;
return(false);
}
byte[] tmpBuff = new byte[16];
byte[] key1Bytes = BitConverter.GetBytes(key1);
byte[] key2Bytes = BitConverter.GetBytes(key2);
byte[] keyExtBytes = String2Byte(keyExt);
Array.Copy(key1Bytes, 0, tmpBuff, 0, key1Bytes.Length);
Array.Copy(key2Bytes, 0, tmpBuff, key1Bytes.Length, key2Bytes.Length);
Array.Copy(keyExtBytes, 0, tmpBuff, key1Bytes.Length + key2Bytes.Length, keyExtBytes.Length);
handshake += ComputeMd5(tmpBuff);
AddSendPkg(String2Byte(handshake));
}
else
{
statusWebSocketConnection = -1;
return(false);
}
}
int nFIN = ((cacheRecvData[0] & 0x80) == 0x80)? 1: 0;
int nOpcode = cacheRecvData[0] & 0x0F;
//int nMask = ((cacheRecvData[1] & 0x80) == 0x80) ? 1 : 0;
int nPayload_length = cacheRecvData[1] & 0x7F;
int nPlayLoadLenByteNum = 1;
int nMaskingKeyByteNum = 4;
if (nPayload_length == 126)
{
nPlayLoadLenByteNum = 3;
}
else if (nPayload_length == 127)
{
nPlayLoadLenByteNum = 9;
}
if (cacheRecvData.Length < (1 + nPlayLoadLenByteNum + nMaskingKeyByteNum))
{
return(true);
}
if (nPayload_length == 126)
{
byte[] nPayload_length_Bytes = new byte[2];
Array.Copy(cacheRecvData, 2, nPayload_length_Bytes, 0, nPayload_length_Bytes.Length);
nPayload_length = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(nPayload_length_Bytes, 0));
}
else if (nPayload_length == 127)
{
byte[] nPayload_length_Bytes = new byte[8];
Array.Copy(cacheRecvData, 2, nPayload_length_Bytes, 0, nPayload_length_Bytes.Length);
nPayload_length = (int)System.Net.IPAddress.NetworkToHostOrder((long)BitConverter.ToInt64(nPayload_length_Bytes, 0));
}
if (cacheRecvData.Length < (1 + nPlayLoadLenByteNum + nMaskingKeyByteNum + nPayload_length))
{
return(true);
}
byte[] aMasking_key = new byte[nMaskingKeyByteNum];
Array.Copy(cacheRecvData, 1 + nPlayLoadLenByteNum, aMasking_key, 0, nMaskingKeyByteNum);
byte[] aPayload_data = new byte[nPayload_length];
Array.Copy(cacheRecvData, 1 + nPlayLoadLenByteNum + nMaskingKeyByteNum, aPayload_data, 0, nPayload_length);
int nLeftSize = cacheRecvData.Length - (1 + nPlayLoadLenByteNum + nMaskingKeyByteNum + nPayload_length);
byte[] leftBytes = new byte[nLeftSize];
if (nLeftSize > 0)
{
Array.Copy(cacheRecvData, 1 + nPlayLoadLenByteNum + nMaskingKeyByteNum + nPayload_length, leftBytes, 0, nLeftSize);
}
cacheRecvData = leftBytes;
for (int i = 0; i < nPayload_length; i++)
{
aPayload_data[i] = (byte)(aPayload_data[i] ^ aMasking_key[i % 4]);
}
FFLog.Trace(string.Format("nOpcode={0},data={1}", nOpcode, aPayload_data.Length));
if (8 == nOpcode)
{
AddSendPkg(BuildPkg(new byte[0], nOpcode));// close
bIsClose = true;
}
else if (2 == nOpcode || 1 == nOpcode || 0 == nOpcode || 9 == nOpcode)
{
if (9 == nOpcode) //!ping
{
AddSendPkg(BuildPkg(new byte[0], 0xA)); // pong
}
if (nFIN == 1)
{
if (dataFragmentation.Length == 0)
{
AddRecvPkg(aPayload_data);
}
else
{
dataFragmentation = MergeArray(dataFragmentation, aPayload_data);
AddRecvPkg(dataFragmentation);
dataFragmentation = new byte[0];
}
}
else
{
dataFragmentation = MergeArray(dataFragmentation, aPayload_data);
}
}
return(true);
}
public EmptyMsgRet OnRouteLogicMsgReq(RouteLogicMsgReq reqMsg)
{
int cmd = reqMsg.Cmd;
Int64 nSessionID = reqMsg.SessionId;
//FFLog.Trace(string.Format("worker RouteLogicMsgReq! {0} {1}", cmd, nSessionID));
bool bIsYuanShenMsg = false;
if ((cmd & 0x4000) != 0)
{
cmd &= ~(0x4000);
bIsYuanShenMsg = true;
}
if (m_dictCmd2Func.ContainsKey(cmd) == false)
{
FFLog.Error(string.Format("worker cmd invalid! {0}", cmd));
return(RPC_NONE);
}
if (cmd == (int)Pbmsg.ClientCmdDef.CLogin)
{
Player playerOld = GetPlayerBySessionID(nSessionID);
if (playerOld != null)
{
ClosePlayer(playerOld);
if (playerOld.nSessionID == nSessionID)
{
m_dictRoles.Remove(nSessionID);
FFLog.Error(string.Format("worker cmd invalid! {0} {1} login twice", cmd, nSessionID));
return(RPC_NONE);
}
}
else
{
Player playerNew = new Player()
{
nSessionID = nSessionID
};
m_dictRoles[nSessionID] = playerNew;
}
}
else
{
if (m_dictRoles.ContainsKey(nSessionID) == false)
{
FFLog.Error(string.Format("worker cmd invalid! {0}, have not recv login msg", cmd));
return(RPC_NONE);
}
}
Player player = GetPlayerBySessionID(nSessionID);
if (bIsYuanShenMsg)
{
if (null == player.playerYS)
{
FFLog.Error(string.Format("playerYS invalid", cmd));
return(RPC_NONE);
}
m_dictCmd2Func[cmd](player.playerYS, reqMsg.Body);
}
else
{
m_dictCmd2Func[cmd](player, reqMsg.Body);
}
return(RPC_NONE);
}
public void HandleLogin(Int64 nSessionID, Pbmsg.LoginReq reqMsg)
{
Player playerOld = RoleMgr.Instance().GetPlayerBySessionID(nSessionID);
if (playerOld != null)
{
if (playerOld.nSessionID == nSessionID)
{
FFLog.Error(string.Format("worker cmd invalid! {0} login twice", nSessionID));
}
return;
}
Player player = new Player()
{
nSessionID = nSessionID
};
RoleMgr.Instance().AddRole(player);
player.strName = reqMsg.Name;
player.nLevel = 1;
Pbmsg.LoginRet retMsg = new Pbmsg.LoginRet()
{
Id = player.GetID(),
Name = reqMsg.Name,
Level = player.nLevel,
};
player.SendPlayerMsg(Pbmsg.ServerCmdDef.SLogin, retMsg);
{
Pbmsg.EnterMapRet enterMapRet = player.BuildEnterMsg();
FFWorker.Instance().GateBroadcastMsg((int)Pbmsg.ServerCmdDef.SEnterMap, enterMapRet);
player.playerYS = new Player()
{
nSessionID = player.nSessionID + 100000, strName = player.strName + "的元神", idZhuTi = player.GetID()
};
player.playerYS.x = player.x - 1;
player.playerYS.y = player.y - 1;
player.playerYS.apprID = player.apprID;
RoleMgr.Instance().AddRole(player.playerYS);
enterMapRet = player.playerYS.BuildEnterMsg();
FFWorker.Instance().GateBroadcastMsg((int)Pbmsg.ServerCmdDef.SEnterMap, enterMapRet);
}
RoleMgr.Instance().ForeachRole((Role roleOther) => {
if (roleOther.GetID() == player.GetID())
{
return;
}
if (roleOther.hp == 0)
{
return;
}
Pbmsg.EnterMapRet enterMapRet = roleOther.BuildEnterMsg();
player.SendPlayerMsg(Pbmsg.ServerCmdDef.SEnterMap, enterMapRet);
});
}
public static void Cleanup()
{
FFLog.GetInstance().DoCleanup();
}
public static void Error(string data)
{
FFLog.GetInstance().LogToFile(FFLogLevel.ERROR, data);
}
public static void Warning(string data)
{
FFLog.GetInstance().LogToFile(FFLogLevel.WARNING, data);
}
public static void Info(string data)
{
FFLog.GetInstance().LogToFile(FFLogLevel.INFO, data);
}
public static void Trace(string data)
{
FFLog.GetInstance().LogToFile(FFLogLevel.TRACE, data);
}
public static void Debug(string data)
{
FFLog.GetInstance().LogToFile(FFLogLevel.DEBUG, data);
}
public void HandleRecv(IFFSocket ffsocket, byte[] strData)
{
if (m_oWSProtocol.HandleRecv(strData))
{
if (ffsocket.GetProtocolType().Length == 0)
{
ffsocket.SetProtocolType("websocket");
}
foreach (var eachWaitSend in m_oWSProtocol.GetSendPkg())
{
ffsocket.AsyncSend(eachWaitSend, false);
}
m_oWSProtocol.ClearSendPkg();
foreach (var eachRecvPkg in m_oWSProtocol.GetRecvPkg())
{
int nHeadEndIndex = -1;
for (int i = 0; i < eachRecvPkg.Length; ++i)
{
if (eachRecvPkg[i] == '\n')
{
nHeadEndIndex = i;
break;
}
}
UInt16 nCmd = 0;
byte[] dataBody = eachRecvPkg;
if (nHeadEndIndex > 0)
{
byte[] bytesHead = new byte[nHeadEndIndex];
dataBody = new byte[eachRecvPkg.Length - nHeadEndIndex - 1];
Array.Copy(eachRecvPkg, 0, bytesHead, 0, bytesHead.Length);
Array.Copy(eachRecvPkg, nHeadEndIndex + 1, dataBody, 0, dataBody.Length);
string[] strHeads = Util.Byte2String(bytesHead).Split(",");
string[] strCmds = strHeads[0].Split(":");
if (strCmds.Length == 2 && strCmds[1].Length > 0)
{
nCmd = Convert.ToUInt16(strCmds[1]);
}
}
FFLog.Trace(string.Format("cmd={0},data={1}", nCmd, Util.Byte2String(dataBody)));
try
{
m_funcMsgHandler(ffsocket, nCmd, dataBody);
}
catch (Exception ex)
{
FFLog.Error("wsscoket.HandleRecv error:" + ex.Message);
}
}
m_oWSProtocol.ClearRecvPkg();
if (m_oWSProtocol.IsClose())
{
ffsocket.Close();
}
return;
}
m_strRecvData = Util.MergeArray(m_strRecvData, strData);
while (m_strRecvData.Length >= 8)
{
size = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt32(m_strRecvData, 0));
cmd = (UInt16)System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(m_strRecvData, 4));
flag = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(m_strRecvData, 6));
FFLog.Trace(string.Format("HandleRecv cmd:{0},len:{1}", cmd, size));
if (m_strRecvData.Length < 8 + size)
{
break;
}
byte[] msgBody = new byte[size];
Array.Copy(m_strRecvData, 8, msgBody, 0, size);
if (m_strRecvData.Length == 8 + size)
{
m_strRecvData = new byte[0];
}
else
{
byte[] leftData = new byte[m_strRecvData.Length - (8 + size)];
Array.Copy(m_strRecvData, 8 + size, leftData, 0, size);
m_strRecvData = leftData;
}
try
{
m_funcMsgHandler(ffsocket, cmd, msgBody);
}
catch (Exception ex)
{
FFLog.Error("scoket.HandleRecv error:" + ex.Message);
}
}
}
public void HandleMsg(IFFSocket ffsocket, UInt16 cmd, string strMsg)
{
//FFLog.Trace(string.Format("ffrpc.FFRpc handleMsg....{0}, {1} [{2}]", cmd, strMsg.Length, System.Threading.Thread.CurrentThread.ManagedThreadId.ToString()));
try
{
switch ((FFRPC_CMD)cmd)
{
case FFRPC_CMD.REGISTER_TO_BROKER_RET:
{
FFNet.DecodeMsg(m_brokerData, strMsg);
FFLog.Trace(string.Format("ffrpc.handleMsg..REGISTER_TO_BROKER_RET..{0}, {1}", m_brokerData.Node_id, m_brokerData.Register_flag));
if (m_brokerData.Register_flag == 1)
{
m_nNodeID = m_brokerData.Node_id; //! -1表示注册失败，0表示同步消息，1表示注册成功
}
} break;
case FFRPC_CMD.BROKER_TO_CLIENT_MSG:
{
BrokerRouteMsgReq reqMsg = new BrokerRouteMsgReq();
FFNet.DecodeMsg(reqMsg, strMsg);
FFLog.Trace(string.Format("ffrpc.BROKER_TO_CLIENT_MSG msgname={0}", reqMsg.Dest_msg_name));
if (reqMsg.Err_info.Length > 0)
{
FFLog.Error(string.Format("FFRpc::handleRpcCallMsg error={0}", reqMsg.Err_info));
if (reqMsg.Callback_id == 0)
{
return;
}
}
try
{
if (reqMsg.Dest_service_name.Length > 0)
{
if (!m_dictFuncs.ContainsKey(reqMsg.Dest_msg_name))
{
reqMsg.Err_info = "interface named " + reqMsg.Dest_msg_name + " not found in rpc";
FFLog.Error(string.Format("FFRpc::handleRpcCallMsg error={0}", reqMsg.Err_info));
reqMsg.Dest_node_id = reqMsg.From_node_id;
reqMsg.Dest_service_name = "";
SendToDestNode(reqMsg);
return;
}
FFRpcFunc destFunc = m_dictFuncs[reqMsg.Dest_msg_name];
destFunc(reqMsg);
}
else
{
if (!m_dictCallBack.ContainsKey(reqMsg.Callback_id))
{
return;
}
FFRpcFunc destFunc = m_dictCallBack[reqMsg.Callback_id];
destFunc(reqMsg);
}
}
catch (Exception ex)
{
FFLog.Error("ffrpc handleMsg" + ex.Message);
}
}
break;
default:
break;
}
}
catch (Exception ex)
{
FFLog.Error("ffprc.Error:" + ex.Message);
}
}
