public List <ArraySegment <byte> > BuildReceiveBuffer()
 {
     // Opportunistic reset to start of buffer
     if (decodeOffset == receiveOffset)
     {
         decodeOffset  = 0;
         receiveOffset = 0;
     }
     return(ByteArrayBuilder.BuildSegmentList(readBuffer, receiveOffset));
 }
Exemplo n.º 2
0
        /// <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);
        }
Exemplo n.º 3
0
        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
            }
        }
Exemplo n.º 4
0
        /// <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;
        }
Exemplo n.º 5
0
        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);
        }
Exemplo n.º 6
0
 public List <ArraySegment <byte> > BuildReceiveBuffer()
 {
     AdjustBuffer();
     return(ByteArrayBuilder.BuildSegmentList(readBuffer, receiveOffset));
 }
Exemplo n.º 7
0
 /// <summary> Default constructor. </summary>
 public BinaryTokenStreamWriter()
 {
     ab = new ByteArrayBuilder();
     Trace("Starting new binary token stream");
 }
Exemplo n.º 8
0
        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);
        }
Exemplo n.º 9
0
 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
     }
 }
Exemplo n.º 10
0
        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);
        }