private void SocketData(int source, int session, string method, byte[] param)
{
NetSprotoType.SocketData socketData = new NetSprotoType.SocketData(param);
long connectionId = socketData.connection;
byte[] tempParam = Convert.FromBase64String(socketData.buffer);
SkynetClusterRequest req = m_skynetPacketManager.UnpackSkynetRequest(tempParam);
if (req == null)
{
return;
}
NetProtocol instance = NetProtocol.GetInstance();
int tag = instance.GetTag("RPC");
RPCParam sprotoRequest = (RPCParam)instance.Protocol.GenRequest(tag, req.Data);
byte[] targetParam = Convert.FromBase64String(sprotoRequest.param);
if (req.Session > 0)
{
SSContext context = new SSContext();
context.IntegerDict["RemoteSession"] = req.Session;
context.LongDict["ConnectionId"] = connectionId;
Call(req.ServiceName, sprotoRequest.method, targetParam, context, TransferCallback);
}
else
{
Send(req.ServiceName, sprotoRequest.method, targetParam);
}
}
private void SocketData(int source, int session, string method, byte[] param)
{
NetSprotoType.SocketData socketData = new NetSprotoType.SocketData(param);
long connectionId = socketData.connection;
byte[] tempParam = Convert.FromBase64String(socketData.buffer);
SkynetClusterResponse response = m_skynetPacketManager.UnpackSkynetResponse(tempParam);
if (response == null)
{
return;
}
byte[] targetParam = null;
if (response.ErrorCode == RPCError.OK)
{
NetProtocol instance = NetProtocol.GetInstance();
RPCParam sprotoResponse = (RPCParam)instance.Protocol.GenResponse(response.ProtoId, response.Data);
targetParam = Convert.FromBase64String(sprotoResponse.param);
}
int remoteSession = response.Session;
ProcessRemoteResponse(remoteSession, targetParam, response.ErrorCode);
}
private void RemoteRequest(int source, string method, NetSprotoType.ClusterClientRequest request, long connectionId, int session)
{
int tag = NetProtocol.GetInstance().GetTag("RPC");
RPCParam rpcParam = new RPCParam();
rpcParam.method = request.method;
rpcParam.param = request.param;
if (m_totalRemoteSession >= Int32.MaxValue)
{
m_totalRemoteSession = 0;
}
int remoteSession = ++m_totalRemoteSession;
List <byte[]> buffers = m_skynetPacketManager.PackSkynetRequest(request.remoteService, remoteSession, tag, rpcParam.encode());
SSContext rpcContext = new SSContext();
rpcContext.LongDict["ConnectionId"] = connectionId;
rpcContext.IntegerDict["RemoteSession"] = remoteSession;
rpcContext.IntegerDict["SourceSession"] = session;
rpcContext.IntegerDict["Source"] = source;
rpcContext.StringDict["Method"] = method;
RPCResponseContext rpcResponseCallback = new RPCResponseContext();
rpcResponseCallback.Callback = RemoteResponseCallback;
rpcResponseCallback.Context = rpcContext;
m_remoteResponseCallbacks.Add(remoteSession, rpcResponseCallback);
Dictionary <int, WaitForResponseRequest> waitResponseDict = null;
bool isExist = m_conn2sessions.TryGetValue(connectionId, out waitResponseDict);
if (!isExist)
{
waitResponseDict = new Dictionary <int, WaitForResponseRequest>();
m_conn2sessions.Add(connectionId, waitResponseDict);
}
WaitForResponseRequest waitForResponseRequest = new WaitForResponseRequest();
waitForResponseRequest.Session = session;
waitForResponseRequest.Source = source;
waitResponseDict.Add(remoteSession, waitForResponseRequest);
NetworkPacket networkPacket = new NetworkPacket();
networkPacket.ConnectionId = connectionId;
networkPacket.TcpObjectId = m_tcpObjectId;
networkPacket.Buffers = buffers;
networkPacket.Type = SocketMessageType.DATA;
NetworkPacketQueue.GetInstance().Push(networkPacket);
}
private void TransferCallback(SSContext context, string method, byte[] param, RPCError error)
{
if (error == RPCError.OK)
{
int tag = NetProtocol.GetInstance().GetTag("RPC");
RPCParam rpcParam = new RPCParam();
rpcParam.method = method;
rpcParam.param = Convert.ToBase64String(param);
int remoteSession = context.IntegerDict["RemoteSession"];
long connectionId = context.LongDict["ConnectionId"];
List<byte[]> bufferList = m_skynetPacketManager.PackSkynetResponse(remoteSession, tag, rpcParam.encode());
NetworkPacket rpcMessage = new NetworkPacket();
rpcMessage.Type = SocketMessageType.DATA;
rpcMessage.TcpObjectId = m_tcpObjectId;
rpcMessage.Buffers = bufferList;
rpcMessage.ConnectionId = connectionId;
NetworkPacketQueue.GetInstance().Push(rpcMessage);
}
else
{
int remoteSession = context.IntegerDict["RemoteSession"];
long connectionId = context.LongDict["ConnectionId"];
List<byte[]> bufferList = m_skynetPacketManager.PackErrorResponse(remoteSession, Encoding.ASCII.GetString(param));
NetworkPacket rpcMessage = new NetworkPacket();
rpcMessage.Type = SocketMessageType.DATA;
rpcMessage.TcpObjectId = m_tcpObjectId;
rpcMessage.Buffers = bufferList;
rpcMessage.ConnectionId = connectionId;
NetworkPacketQueue.GetInstance().Push(rpcMessage);
LoggerHelper.Info(m_serviceAddress,
string.Format("Service:ClusterServer Method:TransferCallback errorCode:{0} errorText:{1}", (int)error, Encoding.ASCII.GetString(param)));
}
}
private void OnError(Message msg)
{
NetProtocol instance = NetProtocol.GetInstance();
int tag = instance.GetTag("Error");
Error.response sprotoError = (Error.response)instance.Protocol.GenResponse(tag, msg.Data);
RPCResponseContext responseCallback = null;
bool isExist = m_responseCallbacks.TryGetValue(msg.RPCSession, out responseCallback);
if (isExist)
{
responseCallback.Callback(responseCallback.Context, msg.Method, Encoding.ASCII.GetBytes(sprotoError.errorText), (RPCError)sprotoError.errorCode);
m_responseCallbacks.Remove(msg.RPCSession);
}
else
{
LoggerHelper.Info(m_serviceAddress, string.Format("Service:{0} session:{1} get error:{2}; error text is {3}",
m_serviceAddress, msg.RPCSession, sprotoError.errorCode, sprotoError.errorText));
}
}
private void Boot(BootServices customBoot)
{
// create global instance first
m_globalMQ = GlobalMQ.GetInstance();
m_serviceSlots = ServiceSlots.GetInstance();
m_netpackQueue = NetworkPacketQueue.GetInstance();
m_timer = SSTimer.GetInstance();
NetProtocol.GetInstance();
// create logger service second
Logger_Init loggerInit = new Logger_Init();
if (m_bootConfig.ContainsKey("Logger"))
{
if (Directory.Exists(m_bootConfig["Logger"].ToString()))
{
loggerInit.logger_path = Path.GetFullPath(m_bootConfig["Logger"].ToString());
}
else
{
DirectoryInfo di = Directory.CreateDirectory(m_bootConfig["Logger"].ToString());
if (di.Exists)
{
loggerInit.logger_path = Path.GetFullPath(m_bootConfig["Logger"].ToString());
}
else
{
loggerInit.logger_path = "../";
}
}
}
else
{
loggerInit.logger_path = "../";
}
SparkServerUtility.NewService("SparkServer.Framework.Service.Logger.LoggerService", "logger", loggerInit.encode());
m_tcpObjectContainer = new TCPObjectContainer();
if (m_bootConfig.ContainsKey("ClusterConfig"))
{
InitCluster();
}
if (m_bootConfig.ContainsKey("Gateway"))
{
InitGateway();
}
customBoot();
LoggerHelper.Info(0, "Start SparkServer Server...");
for (int i = 0; i < m_workerNum; i++)
{
Thread thread = new Thread(new ThreadStart(ThreadWorker));
thread.Start();
}
Thread timerThread = new Thread(new ThreadStart(ThreadTimer));
timerThread.Start();
}
