public EmptyMsgRet OnSessionOfflineReq(SessionOfflineReq reqMsg)
{
Int64 nSessionID = reqMsg.SessionId;
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);
if (player.playerYS != null && m_dictRoles.ContainsKey(player.playerYS.nSessionID) != false)
{
m_dictRoles.Remove(player.playerYS.nSessionID);
retMsg = new Pbmsg.LogoutRet()
{
Id = player.playerYS.GetID(),
Name = player.playerYS.strName,
};
BroadcastPlayerMsg <Pbmsg.LogoutRet>(Pbmsg.ServerCmdDef.SLogout, retMsg);
}
return(RPC_NONE);
}
public bool Init(string strBrokerHost, string strGateListenIpPort, int nGateIndex = 0)
{
m_nGateIndex = nGateIndex;
m_strGateName = string.Format("gate#{0}", m_nGateIndex);
m_ffrpc = new FFRpc(m_strGateName);
if (m_ffrpc.Open(strBrokerHost) == false)
{
FFLog.Error("gate ffrpc open failed!");
return(false);
}
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.Error(string.Format("FFGate open....{0} failed", strGateListenIpPort));
}
return(true);
}
public void HandleBroken(IFFSocket ffsocket)
{
Int64 nNodeID = 0;
string strServiceName = "";
foreach (KeyValuePair <Int64, IFFSocket> kvp in m_dictSockets)
{
if (kvp.Value == ffsocket)
{
nNodeID = kvp.Key;
break;
}
}
if (nNodeID != 0)
{
m_dictSockets.Remove(nNodeID);
foreach (KeyValuePair <string, long> kvp in m_brokerData.Service2node_id)
{
if (kvp.Value == nNodeID)
{
strServiceName = kvp.Key;
break;
}
}
}
if (strServiceName.Length > 0)
{
m_brokerData.Service2node_id.Remove(strServiceName);
}
FFLog.Trace(string.Format("FFBroker HandleBroken....{0}, {1}", nNodeID, strServiceName));
SyncNodeInfo(m_brokerData, null);
}
public bool Call <MSG_TYPE, RET_TYPE>(string strServiceName, MSG_TYPE msgData, TCallBack <RET_TYPE> callback)
where MSG_TYPE : Thrift.Protocol.TBase, new()
where RET_TYPE : Thrift.Protocol.TBase, new()
{
if (!m_brokerData.Service2node_id.ContainsKey(strServiceName))
{
FFLog.Trace(string.Format("ffrpc.Call servervice:{0} not exist", strServiceName));
RET_TYPE retMsg = new RET_TYPE();
callback(retMsg);
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);
reqMsg.Callback_id = ++m_nIDGenerator;
m_dictCallBack[reqMsg.Callback_id] = (BrokerRouteMsgReq dataMsg) =>
{
RET_TYPE retMsg = new RET_TYPE();
FFNet.DecodeMsg(retMsg, dataMsg.Body);
callback(retMsg);
};
SendToDestNode(reqMsg);
return(true);
}
public FFRpc Reg <MSG_TYPE, RET_TYPE>(TUserFunc <MSG_TYPE, RET_TYPE> funcUser)
where MSG_TYPE : Thrift.Protocol.TBase, new()
where RET_TYPE : Thrift.Protocol.TBase, new()
{
MSG_TYPE tmpData = new MSG_TYPE();
string msgname = Type2Name(tmpData);
FFLog.Trace(string.Format("ffrpc.FFRpc Reg....msgname={0}", msgname));
m_dictFuncs[msgname] = (BrokerRouteMsgReq reqMsg) =>
{
MSG_TYPE msgData = new MSG_TYPE();
FFNet.DecodeMsg(msgData, reqMsg.Body);
RET_TYPE retMsg = funcUser(msgData);
if (reqMsg.Callback_id != 0)
{
reqMsg.Dest_node_id = reqMsg.From_node_id;
reqMsg.Dest_service_name = "";
reqMsg.Body = Util.Byte2String(FFNet.EncodeMsg(retMsg));
SendToDestNode(reqMsg);
}
};
return(this);
}
public void HandleClose()
{
if (m_nStatus == 0)
{
return;
}
m_nStatus = 0;
FFNet.GetTaskQueue().Post(() =>
{
if (m_oSocket == null)
{
return;
}
try
{
m_oSocket.Close();
m_oSocket = null;
m_oBuffSending.Clear();
m_oSocketCtrl.HandleBroken(this);
}
catch (Exception ex)
{
FFLog.Trace("scoket: HandleClose Error " + ex.Message);
}
});
}
public void HandleRecv(IFFSocket ffsocket, string strData)
{
m_strRecvData += strData;
while (m_strRecvData.Length >= 8)
{
byte[] btValue = Util.String2Byte(m_strRecvData);
size = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt32(btValue, 0));
cmd = (UInt16)System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(btValue, 4));
flag = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(btValue, 6));
FFLog.Trace(string.Format("HandleRecv cmd:{0},len:{1}", cmd, size));
if (m_strRecvData.Length < 8 + size)
{
break;
}
string strMsg = m_strRecvData.Remove(0, 8);
if (strMsg.Length == size)
{
m_strRecvData = "";
}
else
{
strMsg = strMsg.Remove(size);
m_strRecvData = m_strRecvData.Remove(0, 8 + size);
}
try
{
m_funcMsgHandler(ffsocket, cmd, strMsg);
}
catch (Exception ex)
{
FFLog.Error("scoket.HandleRecv error:" + ex.Message);
}
}
}
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_oSocketCtrl.ForkSelf(), client);
ffsocket.AsyncRecv();
FFLog.Trace(string.Format("scoket: handleAccepted ip:{0}", ffsocket.GetIP()));
}
}
catch (Exception ex)
{
FFLog.Trace("scoket: handleAccepted Error " + ex.Message);
}
if (bRunning)
{
m_oSocket.BeginAccept(new AsyncCallback(HandleAccepted), m_oSocket);
}
}
private void handleSendEnd(IAsyncResult ar)
{
try
{
var socket = ar.AsyncState as Socket;
socket.EndSend(ar);
}
catch (SocketException ex)
{
FFLog.Trace("scoket: send Error " + ex.Message);
HandleClose();
return;
}
FFNet.GetTaskQueue().Post(() =>
{
if (m_oBuffSending.Count > 0)
{
m_oBuffSending.RemoveAt(0);
}
try
{
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 (SocketException ex)
{
FFLog.Trace("scoket: send Error " + ex.Message);
HandleClose();
}
});
}
public void HandleLogout(Int64 nSessionID)
{
FFLog.Trace(string.Format("PlayerHandler.HandleLogout {0}", nSessionID));
Player player = RoleMgr.Instance().GetPlayerBySessionID(nSessionID);
if (player == null)
{
return;
}
RoleMgr.Instance().RemoveRole(nSessionID);
Pbmsg.LogoutRet retMsg = new Pbmsg.LogoutRet()
{
Id = player.GetID(),
Name = player.strName,
};
FFWorker.Instance().GateBroadcastMsg((int)Pbmsg.ServerCmdDef.SLogout, retMsg);
if (player.playerYS != null && RoleMgr.Instance().GetPlayerBySessionID(player.playerYS.nSessionID) != null)
{
RoleMgr.Instance().RemoveRole(player.playerYS.nSessionID);;
retMsg = new Pbmsg.LogoutRet()
{
Id = player.playerYS.GetID(),
Name = player.playerYS.strName,
};
FFWorker.Instance().GateBroadcastMsg((int)Pbmsg.ServerCmdDef.SLogout, retMsg);
}
return;
}
public static void Main(string[] args)
{
string host = "tcp://127.0.0.1:43210";
FFBroker ffbroker = new FFBroker();
ffbroker.Open(host);
string strServiceName = "worker#0";
FFRpc ffrpc = new FFRpc(strServiceName);
if (ffrpc.Open(host) == false)
{
FFLog.Trace("ffrpc open failed!");
}
ffrpc.Reg((SessionEnterWorkerReq req) =>
{
FFLog.Trace(string.Format("ffrpc SessionEnterWorkerReq £¡£¡£¡FromGate={0}", req.From_gate));
return(req);
});
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));
});
});
//FFNet.Timerout(1000, Theout);
//FFNet.Timerout(2000, Theout);
FFNet.Timerout(100000, () =>
{
FFLog.Debug("AAAAAAAAAAAAAAA1");
ffrpc.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();
}
static public void Theout()
{
FFLog.Trace(string.Format("theout! {0}", System.Threading.Thread.CurrentThread.ManagedThreadId.ToString()));
FFLog.Debug("AAAAAAAAAAAAAAA1");
FFLog.Trace("AAAAAAAAAAAAAAA2");
FFLog.Info("AAAAAAAAAAAAAAA3");
FFLog.Warning("AAAAAAAAAAAAAAA4");
FFLog.Error("AAAAAAAAAAAAAAA5");
}
public void Close()
{
try {
m_oSocket.Close();
}
catch (Exception ex)
{
FFLog.Trace("scoket: close Error " + ex.Message);
}
}
public EmptyMsgRet OnSessionEnterWorkerReq(SessionEnterWorkerReq reqMsg)
{
Int64 nBeginUs = DateTime.Now.Ticks / 10;
Int64 nSessionID = reqMsg.SessionId;
FFLog.Trace(string.Format("worker OnSessionEnterWorkerReq session={0}", nSessionID));
this.funcSessionOnEnterWorker?.Invoke(nSessionID, reqMsg.FromWorker, reqMsg.ExtraData);
PerfMonitor.Instance().AddPerf("OnEnterWorker", DateTime.Now.Ticks / 10 - nBeginUs);
return(RPC_NONE);
}
public bool Connect(string ip, int port)
{
try{
m_oSocket.Connect(ip, port);
}
catch (Exception ex)
{
FFLog.Trace("scoket: connect Error " + ex.Message);
return(false);
}
AsyncRecv();
return(true);
}
public static void Main(string[] args)
{
CfgTool.Instance().InitCfg(args);
string strBrokerListen = CfgTool.Instance().GetCfgVal("BrokerListen", "tcp://127.0.0.1:4321");
if (!FFBroker.Instance().Init(strBrokerListen))
{
FFLog.Error("FFBroker open failed!");
return;
}
int nWorkerIndex = 0;
if (FFWorker.Instance().Init(strBrokerListen, nWorkerIndex, listEnableClassNames) == false)
{
FFLog.Trace("FFWorker open failed!");
return;
}
string strGateListen = CfgTool.Instance().GetCfgVal("GateListen", "tcp://*:44000");
if (FFGate.Instance().Init(strBrokerListen, strGateListen) == false)
{
FFLog.Trace("ffGate open failed!");
return;
}
bool bExit = false;
AppDomain.CurrentDomain.ProcessExit += (sender, arg) =>
{
FFLog.Trace("exit!");
bExit = true;
};
Console.CancelKeyPress += (object sender, ConsoleCancelEventArgs e) => {
e.Cancel = true;
FFLog.Trace("exit!!");
bExit = true;
};
while (!bExit)
{
System.Threading.Thread.Sleep(300);
}
FFLog.Trace("exit!!!");
FFGate.Instance().Cleanup();
FFBroker.Instance().Cleanup();
FFWorker.Instance().Cleanup();
FFNet.Cleanup();
FFLog.Cleanup();
}
public void HandleRecv(IAsyncResult ar)
{
if (m_nStatus == 0)
{
FFLog.Trace("scoket: HandleRecv has closed");
return;
}
var length = 0;
try
{
Socket socket = (Socket)ar.AsyncState;
if (socket == null || m_oSocket == null)
{
return;
}
length = socket.EndReceive(ar);
}
catch (Exception ex)
{
FFLog.Warning("scoket: recv Error1 " + ex.Message);
HandleClose();
return;
}
//FFLog.Trace(string.Format("scoket: recv 1111 {0}", length));
if (length == 0)
{
FFLog.Warning("HandleRecv: recv end ok file ");
HandleClose();
return;
}
FFNet.GetTaskQueue().Post(() =>
{
try
{
byte[] message = new byte[length];
Array.Copy(m_oBuffer, 0, message, 0, length);
PostMsg(message);
//接收下一个消息
if (m_oSocket != null)
{
m_oSocket.BeginReceive(m_oBuffer, 0, m_oBuffer.Length, SocketFlags.None, new AsyncCallback(HandleRecv), m_oSocket);
}
}
catch (Exception ex)
{
FFLog.Error("scoket: recv Error2 " + ex.Message);
HandleClose();
}
});
}
public void HandleMsg(IFFSocket ffsocket, UInt16 cmd, byte[] strMsg)
{
//FFLog.Trace(string.Format("FFBroker handleMsg....{0}, {1} [{2}]", cmd, strMsg.Length, System.Threading.Thread.CurrentThread.ManagedThreadId.ToString()));
try
{
switch ((FFRPC_CMD)cmd)
{
case FFRPC_CMD.REGISTER_TO_BROKER_REQ:
{
RegisterToBrokerReq reqMsg = new RegisterToBrokerReq();
FFNet.DecodeMsg(reqMsg, strMsg);
FFLog.Trace(string.Format("FFBroker handleMsg.REGISTER_TO_BROKER_REQ....{0}, {1}", reqMsg.Node_type, reqMsg.Service_name));
if (FFRPC_NODE_TYPE.RPC_NODE == (FFRPC_NODE_TYPE)reqMsg.Node_type)
{
if (m_brokerData.Service2node_id.ContainsKey(reqMsg.Service_name))
{
FFLog.Error(string.Format("FFBroker handleMsg servicename exist....{0}, {1}", reqMsg.Node_type, reqMsg.Service_name));
ffsocket.Close();
return;
}
Int64 nNodeID = allocNodeId();
m_dictSockets[nNodeID] = ffsocket;
m_brokerData.Service2node_id[reqMsg.Service_name] = nNodeID;
m_brokerData.Node_id = nNodeID;
SyncNodeInfo(m_brokerData, ffsocket); //!广播给所有的子节点
}
} break;
case FFRPC_CMD.BROKER_ROUTE_MSG:
{
BrokerRouteMsgReq reqMsg = new BrokerRouteMsgReq();
FFNet.DecodeMsg(reqMsg, strMsg);
FFLog.Trace(string.Format("FFBroker.BROKER_ROUTE_MSG service={0},func={1} Callback={2}",
reqMsg.Dest_service_name, reqMsg.Dest_msg_name, reqMsg.Callback_id));
if (!m_dictSockets.ContainsKey(reqMsg.Dest_node_id))
{
return;
}
IFFSocket destSocket = m_dictSockets[reqMsg.Dest_node_id];
FFNet.SendMsg(destSocket, (UInt16)FFRPC_CMD.BROKER_TO_CLIENT_MSG, reqMsg);
} break;
default: break;
}
}
catch (Exception ex)
{
FFLog.Error("FFBroker.Error:" + ex.Message);
}
}
public bool Open(string strBrokerCfg)
{
if (strBrokerCfg.Length > 0)
{
m_strBrokerHost = strBrokerCfg;
}
FFLog.Trace(string.Format("ffrpc open....{0} begin", m_strBrokerHost));
if (!ConnectToBroker())
{
return(false);
}
return(true);
}
public EmptyMsgRet OnRouteLogicMsgReq(RouteLogicMsgReq reqMsg)
{
int cmd = reqMsg.Cmd;
Int64 nSessionID = reqMsg.Session_id;
FFLog.Trace(string.Format("worker RouteLogicMsgReq! {0} {1}", cmd, nSessionID));
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);
m_dictCmd2Func[cmd](player, reqMsg.Body);
return(RPC_NONE);
}
public static void SendMsg(IFFSocket ffsocket, UInt16 cmdSrc, byte[] strData)
{
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));
}
public EmptyMsgRet OnSessionOfflineReq(SessionOfflineReq reqMsg)
{
Int64 nBeginUs = DateTime.Now.Ticks / 10;
Int64 nSessionID = reqMsg.SessionId;
FFLog.Trace(string.Format("worker OnSessionOfflineReq! {0}", nSessionID));
int cmd = (int)WorkerDef.OFFLINE_CMD;
if (m_dictCmd2Func.ContainsKey(cmd) == false)
{
FFLog.Error(string.Format("worker cmd invalid! {0}", cmd));
return(RPC_NONE);
}
byte[] data = {};
m_dictCmd2Func[cmd].cmdHandler(nSessionID, cmd, data);
PerfMonitor.Instance().AddPerf("OnOffline", DateTime.Now.Ticks / 10 - nBeginUs);
return(RPC_NONE);
}
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 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);
}
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();
}
}
//!切换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;
}