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 void HandleMsg(IFFSocket ffsocket, UInt16 cmd, byte[] strMsg)
{
var sessionData = ffsocket.GetSessionData();
if (sessionData == null)//!first msg
{
string strDefaultWorker = "worker#0";
if (m_ffrpc.IsExistNode(strDefaultWorker) == false)
{
//ffsocket.Close();
FFLog.Error(string.Format("gate worker[{0}] not exist", strDefaultWorker));
FFNet.SendMsg(ffsocket, 256, Util.String2Byte("server is busy!0x0!你好"));
return;
}
Int64 sessionIDNew = ++m_nIDGenerator;
ClientInfo cinfo = new ClientInfo()
{
sockObj = ffsocket, sessionID = sessionIDNew, strAllocWorker = strDefaultWorker
};
ffsocket.SetSessionData(sessionIDNew);
m_dictClients[sessionIDNew] = cinfo;
RouteLogicMsg(cinfo, cmd, strMsg, true);
return;
}
Int64 sessionID = (Int64)sessionData;
if (m_dictClients.ContainsKey(sessionID) == false)
{
return;
}
ClientInfo cinfo2 = m_dictClients[sessionID];
RouteLogicMsg(cinfo2, cmd, strMsg, false);
}
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 bool Close()
{
if (m_socketBroker != null)
{
m_socketBroker.Close();
m_socketBroker = null;
}
return(true);
}
public void HandleBroken(IFFSocket ffsocket)
{
foreach (KeyValuePair <Int64, ClientInfo> kvp in m_dictClients)
{
if (kvp.Value.sockObj == ffsocket)
{
CleanupSession(kvp.Value, true);
break;
}
}
}
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 ConnectToBroker()
{
m_socketBroker = FFNet.Connect(m_strBrokerHost, new SocketMsgHandler(HandleMsg), new SocketBrokenHandler(HandleBroken));
if (null == m_socketBroker)
{
return(false);
}
RegisterToBrokerReq reqMsg = new RegisterToBrokerReq {
Node_type = 2, Service_name = m_strServiceName
};
FFNet.SendMsg(m_socketBroker, (UInt16)FFRPC_CMD.REGISTER_TO_BROKER_REQ, reqMsg);
return(true);
}
private void SyncNodeInfo(RegisterToBrokerRet retMsg, IFFSocket ffsocket)//! 同步给所有的节点，当前的各个节点的信息
{
//!广播给所有的子节点
foreach (IFFSocket s in m_dictSockets.Values)
{
if (s == ffsocket)
{
retMsg.Register_flag = 1;
}
else
{
retMsg.Register_flag = 0;
}
FFNet.SendMsg(s, (UInt16)FFRPC_CMD.REGISTER_TO_BROKER_RET, retMsg);
}
}
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 static void SendMsg(IFFSocket ffsocket, UInt16 cmdSrc, byte[] strData)
{
if (ffsocket.GetProtocolType() == "websocket-text")
{
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));
}
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 SendMsg(IFFSocket ffsocket, UInt16 cmd, Thrift.Protocol.TBase reqMsg)
{
byte[] strData = EncodeMsg(reqMsg);
SendMsg(ffsocket, cmd, strData);
}
public void HandleBroken(IFFSocket ffsocket)
{
m_funcBroken(ffsocket);
}
public void HandleBroken(IFFSocket ffsocket)
{
}
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);
}
}
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);
}
}
}
