public List <ArraySegment <byte> > BuildReceiveBuffer()
{
// Opportunistic reset to start of buffer
if (decodeOffset == receiveOffset)
{
decodeOffset = 0;
receiveOffset = 0;
}
return(ByteArrayBuilder.BuildSegmentList(readBuffer, receiveOffset));
}
/// <summary>
///
/// </summary>
/// <param name="b"></param>
/// <returns></returns>
public ByteArrayBuilder Append(ByteArrayBuilder b)
{
if ((currentBuffer != null) && (currentOffset > 0))
{
completedBuffers.Add(new ArraySegment <byte>(currentBuffer, 0, currentOffset));
completedLength += currentOffset;
}
completedBuffers.AddRange(b.completedBuffers);
completedLength += b.completedLength;
currentBuffer = b.currentBuffer;
currentOffset = b.currentOffset;
return(this);
}
internal static void WriteConnectionPreemble(Socket socket, GrainId grainId)
{
int size = 0;
byte[] grainIdByteArray = null;
if (grainId != null)
{
grainIdByteArray = grainId.ToByteArray();
size += grainIdByteArray.Length;
}
ByteArrayBuilder sizeArray = new ByteArrayBuilder();
sizeArray.Append(size);
socket.Send(sizeArray.ToBytes()); // The size of the data that is coming next.
//socket.Send(guid.ToByteArray()); // The guid of client/silo id
if (grainId != null)
{
// No need to send in a loop.
// From MSDN: If you are using a connection-oriented protocol, Send will block until all of the bytes in the buffer are sent,
// unless a time-out was set by using Socket.SendTimeout.
// If the time-out value was exceeded, the Send call will throw a SocketException.
socket.Send(grainIdByteArray); // The grainId of the client
}
}
/// <summary>
///
/// </summary>
/// <param name="b"></param>
/// <returns></returns>
public ByteArrayBuilder Append(ByteArrayBuilder b)
{
if ((currentBuffer != null) && (currentOffset > 0))
{
completedBuffers.Add(new ArraySegment<byte>(currentBuffer, 0, currentOffset));
completedLength += currentOffset;
}
completedBuffers.AddRange(b.completedBuffers);
completedLength += b.completedLength;
currentBuffer = b.currentBuffer;
currentOffset = b.currentOffset;
return this;
}
public bool TryDecodeMessage(out Message msg)
{
msg = null;
// if we read the entire buffer, assume we could have read more if buffer was bigger, and increase buffer size.
if (receiveOffset == currentBufferSize && currentBufferSize < maxSustainedBufferSize)
{
GrowBuffer();
}
// Is there enough read into the buffer to continue (at least read the lengths?)
if (receiveOffset - decodeOffset < CalculateKnownMessageSize())
{
return(false);
}
// parse lengths if needed
if (headerLength == 0 || bodyLength == 0)
{
// get length segments
List <ArraySegment <byte> > lenghts = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, decodeOffset, Message.LENGTH_HEADER_SIZE);
// copy length segment to buffer
int lengthBufferoffset = 0;
foreach (ArraySegment <byte> seg in lenghts)
{
Buffer.BlockCopy(seg.Array, seg.Offset, lengthBuffer, lengthBufferoffset, seg.Count);
lengthBufferoffset += seg.Count;
}
// read lengths
headerLength = BitConverter.ToInt32(lengthBuffer, 0);
bodyLength = BitConverter.ToInt32(lengthBuffer, 4);
}
// If message is too big for current buffer size, grow
while (decodeOffset + CalculateKnownMessageSize() > currentBufferSize)
{
GrowBuffer();
}
// Is there enough read into the buffer to read full message
if (receiveOffset - decodeOffset < CalculateKnownMessageSize())
{
return(false);
}
// decode header
int headerOffset = decodeOffset + Message.LENGTH_HEADER_SIZE;
List <ArraySegment <byte> > header = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, headerOffset, headerLength);
// decode body
int bodyOffset = headerOffset + headerLength;
List <ArraySegment <byte> > body = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, bodyOffset, bodyLength);
// need to maintain ownership of buffer, so if we are supporting forwarding we need to duplicate the body buffer.
if (supportForwarding)
{
body = DuplicateBuffer(body);
}
// build message
msg = new Message(header, body, !supportForwarding);
MessagingStatisticsGroup.OnMessageReceive(msg, headerLength, bodyLength);
if (headerLength + bodyLength > Message.LargeMessageSizeThreshold)
{
Log.Info(ErrorCode.Messaging_LargeMsg_Incoming, "Receiving large message Size={0} HeaderLength={1} BodyLength={2}. Msg={3}",
headerLength + bodyLength, headerLength, bodyLength, msg.ToString());
if (Log.IsVerbose3)
{
Log.Verbose3("Received large message {0}", msg.ToLongString());
}
}
// update parse receiveOffset and clear lengths
decodeOffset = bodyOffset + bodyLength;
headerLength = 0;
bodyLength = 0;
return(true);
}
public List <ArraySegment <byte> > BuildReceiveBuffer()
{
AdjustBuffer();
return(ByteArrayBuilder.BuildSegmentList(readBuffer, receiveOffset));
}
/// <summary> Default constructor. </summary>
public BinaryTokenStreamWriter()
{
ab = new ByteArrayBuilder();
Trace("Starting new binary token stream");
}
public bool TryDecodeMessage(out Message msg)
{
msg = null;
// Is there enough read into the buffer to continue (at least read the lengths?)
if (receiveOffset - decodeOffset < CalculateKnownMessageSize())
{
return(false);
}
// parse lengths if needed
if (headerLength == 0 || bodyLength == 0)
{
// get length segments
List <ArraySegment <byte> > lenghts = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, decodeOffset, Message.LENGTH_HEADER_SIZE);
// copy length segment to buffer
int lengthBufferoffset = 0;
foreach (ArraySegment <byte> seg in lenghts)
{
Buffer.BlockCopy(seg.Array, seg.Offset, lengthBuffer, lengthBufferoffset, seg.Count);
lengthBufferoffset += seg.Count;
}
// read lengths
headerLength = BitConverter.ToInt32(lengthBuffer, 0);
bodyLength = BitConverter.ToInt32(lengthBuffer, 4);
}
// If message is too big for current buffer size, grow
while (decodeOffset + CalculateKnownMessageSize() > currentBufferSize)
{
GrowBuffer();
}
// Is there enough read into the buffer to read full message
if (receiveOffset - decodeOffset < CalculateKnownMessageSize())
{
return(false);
}
// decode header
int headerOffset = decodeOffset + Message.LENGTH_HEADER_SIZE;
List <ArraySegment <byte> > header = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, headerOffset, headerLength);
// decode body
int bodyOffset = headerOffset + headerLength;
List <ArraySegment <byte> > body = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, bodyOffset, bodyLength);
// build message
this.deserializationContext.Reset();
this.deserializationContext.StreamReader.Reset(header);
msg = new Message
{
Headers = SerializationManager.DeserializeMessageHeaders(this.deserializationContext)
};
try
{
if (this.supportForwarding)
{
// If forwarding is supported, then deserialization will be deferred until the body value is needed.
// Need to maintain ownership of buffer, so we need to duplicate the body buffer.
msg.SetBodyBytes(this.DuplicateBuffer(body));
}
else
{
// Attempt to deserialize the body immediately.
msg.DeserializeBodyObject(this.serializationManager, body);
}
}
finally
{
MessagingStatisticsGroup.OnMessageReceive(msg, headerLength, bodyLength);
if (headerLength + bodyLength > this.serializationManager.LargeObjectSizeThreshold)
{
Log.Info(
ErrorCode.Messaging_LargeMsg_Incoming,
"Receiving large message Size={0} HeaderLength={1} BodyLength={2}. Msg={3}",
headerLength + bodyLength,
headerLength,
bodyLength,
msg.ToString());
if (Log.IsEnabled(LogLevel.Trace))
{
Log.Trace("Received large message {0}", msg.ToLongString());
}
}
// update parse receiveOffset and clear lengths
decodeOffset = bodyOffset + bodyLength;
headerLength = 0;
bodyLength = 0;
AdjustBuffer();
}
return(true);
}
internal static void WriteConnectionPreemble(Socket socket, GrainId grainId)
{
int size = 0;
byte[] grainIdByteArray = null;
if (grainId != null)
{
grainIdByteArray = grainId.ToByteArray();
size += grainIdByteArray.Length;
}
ByteArrayBuilder sizeArray = new ByteArrayBuilder();
sizeArray.Append(size);
socket.Send(sizeArray.ToBytes()); // The size of the data that is coming next.
//socket.Send(guid.ToByteArray()); // The guid of client/silo id
if (grainId != null)
{
// No need to send in a loop.
// From MSDN: If you are using a connection-oriented protocol, Send will block until all of the bytes in the buffer are sent,
// unless a time-out was set by using Socket.SendTimeout.
// If the time-out value was exceeded, the Send call will throw a SocketException.
socket.Send(grainIdByteArray); // The grainId of the client
}
}
public bool TryDecodeMessage(out Message msg)
{
msg = null;
// Is there enough read into the buffer to continue (at least read the lengths?)
if (receiveOffset - decodeOffset < KnownMessageSize())
{
return(false);
}
// parse lengths if needed
if (headerLength == 0 || bodyLength == 0)
{
// get length segments
List <ArraySegment <byte> > lenghts = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, decodeOffset, Message.LENGTH_HEADER_SIZE);
// copy length segment to buffer
int lengthBufferoffset = 0;
foreach (ArraySegment <byte> seg in lenghts)
{
Buffer.BlockCopy(seg.Array, seg.Offset, lengthBuffer, lengthBufferoffset, seg.Count);
lengthBufferoffset += seg.Count;
}
// read lengths
headerLength = BitConverter.ToInt32(lengthBuffer, 0);
bodyLength = BitConverter.ToInt32(lengthBuffer, 4);
}
// If message is too big for default buffer size, grow
while (decodeOffset + KnownMessageSize() > currentBufferSize)
{
//TODO: Add configurable max message size for safety
//TODO: Review networking layer and add max size checks to all dictionaries, arrays, or other variable sized containers.
// double buffer size up to max grow block size, then only grow it in those intervals
int growBlockSize = Math.Min(currentBufferSize, GROW_MAX_BLOCK_SIZE);
readBuffer.AddRange(BufferPool.GlobalPool.GetMultiBuffer(growBlockSize));
currentBufferSize += growBlockSize;
}
// Is there enough read into the buffer to read full message
if (receiveOffset - decodeOffset < KnownMessageSize())
{
return(false);
}
// decode header
int headerOffset = decodeOffset + Message.LENGTH_HEADER_SIZE;
List <ArraySegment <byte> > header = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, headerOffset, headerLength);
// decode body
int bodyOffset = headerOffset + headerLength;
List <ArraySegment <byte> > body = ByteArrayBuilder.BuildSegmentListWithLengthLimit(readBuffer, bodyOffset, bodyLength);
// need to maintain ownership of buffer, so if we are supporting forwarding we need to duplicate the body buffer.
if (supportForwarding)
{
body = DuplicateBuffer(body);
}
// build message
msg = new Message(header, body, !supportForwarding);
MessagingStatisticsGroup.OnMessageReceive(msg, headerLength, bodyLength);
if (headerLength + bodyLength > Message.LargeMessageSizeThreshold)
{
Log.Info(ErrorCode.Messaging_LargeMsg_Incoming, "Receiving large message Size={0} HeaderLength={1} BodyLength={2}. Msg={3}",
headerLength + bodyLength, headerLength, bodyLength, msg.ToString());
if (Log.IsVerbose3)
{
Log.Verbose3("Received large message {0}", msg.ToLongString());
}
}
// update parse receiveOffset and clear lengths
decodeOffset = bodyOffset + bodyLength;
headerLength = 0;
bodyLength = 0;
// drop buffers consumed in message and adjust parse receiveOffset
// TODO: This can be optimized further. Linked lists?
int consumedBytes = 0;
while (readBuffer.Count != 0)
{
ArraySegment <byte> seg = readBuffer[0];
if (seg.Count <= decodeOffset - consumedBytes)
{
consumedBytes += seg.Count;
readBuffer.Remove(seg);
BufferPool.GlobalPool.Release(seg.Array);
}
else
{
break;
}
}
decodeOffset -= consumedBytes;
receiveOffset -= consumedBytes;
if (consumedBytes != 0)
{
if (currentBufferSize <= maxSustainedBufferSize)
{
readBuffer.AddRange(BufferPool.GlobalPool.GetMultiBuffer(consumedBytes));
}
else
{
// shrink buffer to DEFAULT_MAX_SUSTAINED_RECEIVE_BUFFER_SIZE
int backfillBytes = Math.Max(consumedBytes + maxSustainedBufferSize - currentBufferSize, 0);
currentBufferSize -= consumedBytes;
currentBufferSize += backfillBytes;
if (backfillBytes > 0)
{
readBuffer.AddRange(BufferPool.GlobalPool.GetMultiBuffer(backfillBytes));
}
}
}
return(true);
}