private void putResponse(TcpClient client, MemoryStream ms, ResponseMsg response, SlimSerializer serializer)
{
var frameBegin = Consts.PACKET_DELIMITER_LENGTH;
ms.Position = frameBegin;
var frame = new WireFrame(Binding.FrameFormat, true, response.RequestID);
// Write the frame
var frameSize = frame.Serialize(ms);
// Write the message
DoEncodeResponse(ms, response, serializer);
var size = (int)ms.Position - frameBegin;
var buffer = ms.GetBuffer(); //no stream expansion beyond this point
buffer.WriteBEInt32(0, size);
Binding.DumpMsg(true, response, buffer, 0, (int)ms.Position);
if (size > Binding.MaxMsgSize)
{
Instrumentation.ServerSerializedOverMaxMsgSizeErrorEvent.Happened(Node);
throw new MessageSizeException(size, Binding.MaxMsgSize, "putResponse()", serializer.BatchTypesAdded);
}
client.GetStream().Write(buffer, 0, (int)ms.Position);
stat_MsgSent();
stat_BytesSent(size);
}
private void sendSocketResponse(MpxServerSocket socket, ResponseMsg response)
{
var chunk = socket.GetSendChunk();
try
{
var frame = new WireFrame(WireFrame.SLIM_FORMAT, true, response.RequestID);
var size = serialize(chunk, frame, response);
var wm = new WireMsg(chunk);
Binding.DumpMsg(true, response, chunk.GetBuffer(), 0, (int)chunk.Position);
if (size > Binding.MaxMsgSize)
{
Instrumentation.ServerSerializedOverMaxMsgSizeErrorEvent.Happened(Node);
throw new MessageSizeException(size, Binding.MaxMsgSize, "sendResponse(" + response.RequestID + ")");
}
socket.Send(wm);
stat_MsgSent();
stat_BytesSent(size);
}
catch
{
stat_Errors();
throw;
}
finally
{
socket.ReleaseSendChunk();
}
}
private RequestMsg deserialize(ref WireMsg wmsg)
{
var chunk = wmsg.Data;
chunk.Position = sizeof(int);
WireFrame frame;
RequestMsg result = null;
var arrivalTime = Binding.StatTimeTicks;
object received = null;
try
{
try
{
frame = new WireFrame(chunk);
wmsg.Frame = frame;
received = Binding.Serializer.Deserialize(chunk);
}
catch
{
Instrumentation.ServerDeserializationErrorEvent.Happened(Node);
throw;
}
if (received == null)
{
throw new ProtocolException(StringConsts.GLUE_UNEXPECTED_MSG_ERROR + "RequestMsg. Got <null>");
}
result = received as RequestMsg;
if (result == null)
{
throw new ProtocolException(StringConsts.GLUE_UNEXPECTED_MSG_ERROR + "RequestMsg");
}
stat_MsgReceived();
stat_BytesReceived(chunk.Position);
}
catch
{
stat_Errors();
throw;
}
finally
{
Binding.DumpMsg(true, received as Msg, chunk.GetBuffer(), 0, (int)chunk.Position);
}
result.__SetArrivalTimeStampTicks(arrivalTime);
return(result);
}
private RequestMsg getRequest(TcpClient client, MemoryStream ms, SlimSerializer serializer)
{
var nets = client.GetStream();
var msb = ms.GetBuffer();
var frameBegin = Consts.PACKET_DELIMITER_LENGTH;
SyncBinding.socketRead(nets, msb, 0, frameBegin);
var size = msb.ReadBEInt32();
if (size < 1 || size > Binding.MaxMsgSize)
{
Instrumentation.ServerGotOverMaxMsgSizeErrorEvent.Happened(Node);
// This is unrecoverable error - close the channel!
throw new MessageSizeException(size, Binding.MaxMsgSize, "getRequest()", closeChannel: true);
}
ms.SetLength(Consts.PACKET_DELIMITER_LENGTH + size); //this may invalidate msb
SyncBinding.socketRead(nets, ms.GetBuffer(), Consts.PACKET_DELIMITER_LENGTH, size);
var arrivalTime = Binding.StatTimeTicks;
ms.Position = Consts.PACKET_DELIMITER_LENGTH;
RequestMsg result = null;
WireFrame frame;
try
{
try
{
frame = new WireFrame(ms);
result = DoDecodeRequest(frame, ms, serializer);
}
catch
{
Instrumentation.ServerDeserializationErrorEvent.Happened(Node);
throw;
}
}
finally
{
Binding.DumpMsg(true, result, ms.GetBuffer(), 0, size + Consts.PACKET_DELIMITER_LENGTH);
}
result.__SetArrivalTimeStampTicks(arrivalTime);
stat_MsgReceived();
stat_BytesReceived(size);
return(result);
}
private ResponseMsg getResponse()
{
var ms = m_MemStream;
var nets = m_Client.GetStream();
var msb = ms.GetBuffer();
var frameBegin = Consts.PACKET_DELIMITER_LENGTH;
SyncBinding.socketRead(nets, msb, 0, frameBegin);
var size = msb.ReadBEInt32();
if (size < 1 || size > Binding.MaxMsgSize)
{
Instrumentation.ClientGotOverMaxMsgSizeErrorEvent.Happened(App.Instrumentation, Node);
// There is no recovery here - close the channel!
throw new MessageSizeException(size, Binding.MaxMsgSize, "getResponse()", closeChannel: true);
}
ms.SetLength(frameBegin + size); //this may invalidate msb
SyncBinding.socketRead(nets, ms.GetBuffer(), frameBegin, size);
var arrivalTime = Binding.StatTimeTicks;
ms.Position = Consts.PACKET_DELIMITER_LENGTH;
ResponseMsg result = null;
WireFrame frame;
try
{
try
{
frame = new WireFrame(ms);
result = DoDecodeResponse(frame, ms);
}
catch
{
Instrumentation.ClientDeserializationErrorEvent.Happened(App.Instrumentation, Node);
throw;
}
}
finally
{
Binding.DumpMsg(false, result, ms.GetBuffer(), 0, size + Consts.PACKET_DELIMITER_LENGTH);
}
result.__SetArrivalTimeStampTicks(arrivalTime);
stat_MsgReceived();
stat_BytesReceived(size);
return(result);
}
private int serialize(MemChunk chunk, WireFrame frame, Msg msg)
{
chunk.Position = sizeof(int);
frame.Serialize(chunk);
Binding.Serializer.Serialize(chunk, msg);
var size = (int)chunk.Position; //includes 4 byte len prefix
var buff = chunk.GetBuffer(); //no stream expansion beyond this point
buff.WriteBEInt32(0, size);
return(size);
}
private CallSlot sendRequest(ClientEndPoint endpoint, RequestMsg request, CallOptions options)
{
if (m_PriorDispatchTimeoutMs != options.DispatchTimeoutMs)
{
m_Client.Socket.SendTimeout = options.DispatchTimeoutMs;
m_PriorDispatchTimeoutMs = options.DispatchTimeoutMs;
}
if (m_PriorTimeoutMs != options.TimeoutMs)
{
m_Client.Socket.ReceiveTimeout = options.TimeoutMs;
m_PriorTimeoutMs = options.TimeoutMs;
}
var chunk = m_Client.GetSendChunk();
try
{
var frame = new WireFrame(WireFrame.SLIM_FORMAT, request.OneWay, request.RequestID);
var size = serialize(chunk, frame, request);
var wm = new WireMsg(chunk);
Binding.DumpMsg(false, request, chunk.GetBuffer(), 0, (int)chunk.Position);
if (size > Binding.MaxMsgSize)
{
Instrumentation.ClientSerializedOverMaxMsgSizeErrorEvent.Happened(App.Instrumentation, Node);
throw new MessageSizeException(size, Binding.MaxMsgSize, "sendRequest(" + request.RequestID + ")");
}
m_Client.Send(wm);
stat_MsgSent();
stat_BytesSent(wm.BufferUsedSize);
}
catch
{
stat_Errors();
throw;
}
finally
{
m_Client.ReleaseSendChunk();
}
//regardless of (request.OneWay) we return callslot anyway
return(new CallSlot(endpoint, this, request, CallStatus.Dispatched, options.TimeoutMs));
}
/// <summary>
/// Decode the ResponseMsg per fame.Format, ms.Position is set after frame
/// </summary>
protected virtual RequestMsg DoDecodeRequest(WireFrame frame, MemoryStream ms, ISerializer serializer)
{
var recv = serializer.Deserialize(ms);
if (recv == null)
{
throw new ProtocolException(StringConsts.GLUE_UNEXPECTED_MSG_ERROR + "RequestMsg. Got <null>");
}
var result = recv as RequestMsg;
if (result == null)
{
throw new ProtocolException(StringConsts.GLUE_UNEXPECTED_MSG_ERROR + "RequestMsg");
}
return(result);
}
private void putRequest(RequestMsg request)
{
var ms = m_MemStream;
var dataBegin = Consts.PACKET_DELIMITER_LENGTH;
ms.Position = dataBegin;
var frame = new WireFrame(Binding.FrameFormat, request.OneWay, request.RequestID);
// Write the frame
var frameSize = frame.Serialize(ms);
// Write the message
DoEncodeRequest(ms, request);
var size = (int)ms.Position - dataBegin;
var buffer = ms.GetBuffer(); //no stream expansion beyond this point
buffer.WriteBEInt32(0, size);
Binding.DumpMsg(false, request, buffer, 0, (int)ms.Position);
if (size > Binding.MaxMsgSize)
{
Instrumentation.ClientSerializedOverMaxMsgSizeErrorEvent.Happened(App.Instrumentation, Node);
//do not tear the socket, however we may have added extra types to Serializer typereg that server never received
//so in that case we do close the channel
throw new MessageSizeException(size, Binding.MaxMsgSize, "putRequest(" + request.RequestID + ")", m_Serializer.BatchTypesAdded);
}
m_Client.GetStream().Write(buffer, 0, (int)ms.Position);
stat_MsgSent();
stat_BytesSent(size);
}
