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); }
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); }