public void SendBlob(string destID, int contractID, IMessage body, int blobSize = 1024)
{
List <MessagePacket> packets = new List <MessagePacket>();
byte[] buffer = body.ToByteArray();
int blobLength = buffer.Length / blobSize;
if (blobLength != 0 && buffer.Length % blobLength > 0)
{
blobLength++;
}
int blobID = MessageIDCreater.GetNewID();
if (blobLength == 0)
{
BlobContract contract = new BlobContract()
{
BlobID = blobID,
FragmentIndex = 0,
Fragment = ByteString.CopyFrom(buffer),
IsLast = true
};
packets.Add(new MessagePacket(GloblParams.CurrentClientID, destID,
GloblParams.CurrentClientType, MessageType.Blob, contractID, contract.ToByteArray()));
}
else
{
for (int i = 0; i < blobLength; i++)
{
int startIndex = i * blobSize;
int endIndex = ((i + 1) * blobSize) > buffer.Length ? buffer.Length : ((i + 1) * blobSize);
int length = endIndex - startIndex;
byte[] sendBuffer = new byte[length];
System.Buffer.BlockCopy(buffer, startIndex, sendBuffer, 0, length);
BlobContract contract = new BlobContract()
{
BlobID = blobID,
FragmentIndex = i,
Fragment = ByteString.CopyFrom(sendBuffer),
IsLast = i == blobLength
};
packets.Add(new MessagePacket(GloblParams.CurrentClientID, destID,
GloblParams.CurrentClientType, MessageType.Blob, contractID, contract.ToByteArray()));
}
}
messageBus.SendMessage(packets);
}
public void Process(RequestInfo request)
{
var message = request.MessagePacket;
try
{
#region Noraml
if (message.MessageHeader.MessageType == MessageType.Noraml)
{
if (message.MessageHeader.DestUserID == GloblParams.DefaultServerID)
{
customizeHandler.Handle(message.MessageHeader.SourceUserID, message.ContractID, message.BodyContent);
}
else
{
basicController.Send(message.MessageHeader.DestUserID, message);
}
}
#endregion
#region Ack_Req
else if (message.MessageHeader.MessageType == MessageType.Ack_Req)
{
if (message.MessageHeader.DestUserID == GloblParams.DefaultServerID)
{
ResponseAck(request.Channel, message);
customizeHandler.Handle(message.MessageHeader.SourceUserID, message.ContractID, message.BodyContent);
}
else
{
basicController.Send(message.MessageHeader.DestUserID, message);
}
}
#endregion
#region Blob
else if (message.MessageHeader.MessageType == MessageType.Blob)
{
if (message.MessageHeader.DestUserID == GloblParams.DefaultServerID)
{
BlobContract contract = BlobContract.Parser.ParseFrom(message.BodyContent);
string keyStr = message.MessageHeader.SourceUserID + contract.BlobID.ToString();
BlobItem item = hotDic.Get(keyStr);
if (item == null)
{
item = new BlobItem();
hotDic.Add(keyStr, item);
}
item.Add(contract.FragmentIndex, contract.Fragment);
if (contract.IsLast)
{
BlobItem blob = this.hotDic.GetAndRemove(keyStr);
MemoryStream stream = new MemoryStream();
foreach (var blobItem in blob)
{
blobItem.Value.WriteTo(stream);
}
byte[] bytes = stream.ToArray();
stream.Dispose();
customizeHandler.Handle(message.MessageHeader.SourceUserID, message.ContractID, bytes);
}
}
else
{
basicController.Send(message.MessageHeader.DestUserID, message);
}
}
#endregion
#region Ack_Resp
else if (message.MessageHeader.MessageType == MessageType.Ack_Resp)
{
basicController.Send(message.MessageHeader.DestUserID, message);
}
#endregion
#region Query_Req
else if (message.MessageHeader.MessageType == MessageType.Query_Req)
{
if (message.MessageHeader.DestUserID == GloblParams.DefaultServerID)
{
byte[] result = customizeHandler.HandleQuery(message.MessageHeader.SourceUserID, message.ContractID, message.BodyContent);
ResponseQuery(request.Channel, MessageType.Query_Resp, message, result);
}
else
{
basicController.Send(message.MessageHeader.DestUserID, message);
}
}
#endregion
#region Query_Resp
else if (message.MessageHeader.MessageType == MessageType.Query_Resp)
{
basicController.Send(message.MessageHeader.DestUserID, message);
}
#endregion
#region Login
else if (message.MessageHeader.MessageType == MessageType.Login)
{
LoginContract loginContract = LoginContract.Parser.ParseFrom(message.BodyContent);
string cause;
LoginResultContract result = null;
bool verResult = basicHandler.VerifyUser(loginContract, request.Channel, out cause);
this.basicController.userManager.Add(loginContract.Uid, request.Channel);
result = new LoginResultContract()
{
Result = verResult ? 0 : 1,
Failure = cause
};
ResponseQuery(request.Channel, MessageType.LoginResp, message, result.ToByteArray());
}
#endregion
else
{
//handler.HandleQuery(request);
}
}
catch
{
}
}
public void Process(RequestInfo requestInfo)
{
MessagePacket messagePacket = requestInfo.MessagePacket;
try
{
if (messagePacket.MessageHeader.MessageType == MessageType.Noraml)
{
this.handler.Handle(messagePacket.MessageHeader.SourceUserID, messagePacket.ContractID, messagePacket.BodyContent);
}
else
{
#region Blob
if (messagePacket.MessageHeader.MessageType == MessageType.Blob)
{
BlobContract blobContract = BlobContract.Parser.ParseFrom(messagePacket.BodyContent);
string key = messagePacket.MessageHeader.SourceUserID + blobContract.BlobID.ToString();
BlobItem blobItem = this.hotDic.Get(key);
if (blobItem == null)
{
blobItem = new BlobItem();
this.hotDic.Add(key, blobItem);
}
blobItem.Add(blobContract.FragmentIndex, blobContract.Fragment);
bool isLast = blobContract.IsLast;
if (isLast)
{
BlobItem andRemove = this.hotDic.GetAndRemove(key);
MemoryStream memoryStream = new MemoryStream();
foreach (KeyValuePair <int, ByteString> current in andRemove)
{
current.Value.WriteTo(memoryStream);
}
byte[] info = memoryStream.ToArray();
memoryStream.Dispose();
this.handler.Handle(messagePacket.MessageHeader.SourceUserID, messagePacket.ContractID, info);
}
}
#endregion
#region Ack
else
{
if (messagePacket.MessageHeader.MessageType == MessageType.Ack_Req)
{
this.ResponseAck(requestInfo.Channel, messagePacket);
this.handler.Handle(messagePacket.MessageHeader.SourceUserID, messagePacket.ContractID, messagePacket.BodyContent);
}
else
{
if (messagePacket.MessageHeader.MessageType == MessageType.Ack_Resp ||
messagePacket.MessageHeader.MessageType == MessageType.Query_Resp ||
messagePacket.MessageHeader.MessageType == MessageType.LoginResp)
{
if (this.messageBag.ContainsKey(messagePacket.MessageHeader.MessageID))
{
this.messageBag[messagePacket.MessageHeader.MessageID].SetResult(messagePacket.BodyContent);
}
}
else
{
if (messagePacket.MessageHeader.MessageType == MessageType.Query_Req)
{
byte[] body = this.handler.HandleQuery(messagePacket.MessageHeader.SourceUserID, messagePacket.ContractID, messagePacket.BodyContent);
this.ResponseQuery(requestInfo.Channel, messagePacket, body);
}
}
}
}
#endregion
}
}
catch (Exception ex)
{
throw ex;
}
}
