コード例 #1
0
        void Write(IByteBufferAllocator allocator, FullBulkStringRedisMessage message, ICollection <object> output)
        {
            Contract.Requires(allocator != null);
            Contract.Requires(message != null);
            Contract.Requires(output != null);

            IByteBuffer buffer = allocator.Buffer(
                RedisConstants.TypeLength
                + (message.IsNull ? RedisConstants.NullLength : RedisConstants.LongValueMaximumLength)
                + RedisConstants.EndOfLineLength);

            buffer.WriteByte((char)RedisMessageType.BulkString);
            if (message.IsNull)
            {
                buffer.WriteShort(RedisConstants.Null);
                buffer.WriteShort(RedisConstants.EndOfLine);

                output.Add(buffer);
            }
            else
            {
                int    readableBytes = message.Content.ReadableBytes;
                byte[] bytes         = this.NumberToBytes(readableBytes);
                buffer.WriteBytes(bytes);
                buffer.WriteShort(RedisConstants.EndOfLine);

                output.Add(buffer);
                output.Add(message.Content.Retain());
                output.Add(allocator
                           .Buffer(RedisConstants.EndOfLineLength)
                           .WriteShort(RedisConstants.EndOfLine));
            }
        }
コード例 #2
0
        static void EncodeConnAckMessage(IByteBufferAllocator bufferAllocator, ConnAckPacket message, List <object> output)
        {
            IByteBuffer buffer = null;

            try
            {
                buffer = bufferAllocator.Buffer(4);
                buffer.WriteByte(CalculateFirstByteOfFixedHeader(message));
                buffer.WriteByte(2); // remaining length
                if (message.SessionPresent)
                {
                    buffer.WriteByte(1); // 7 reserved 0-bits and SP = 1
                }
                else
                {
                    buffer.WriteByte(0); // 7 reserved 0-bits and SP = 0
                }
                buffer.WriteByte((byte)message.ReturnCode);


                output.Add(buffer);
                buffer = null;
            }
            finally
            {
                buffer?.SafeRelease();
            }
        }
コード例 #3
0
        static void EncodeSubAckMessage(IByteBufferAllocator bufferAllocator, SubAckPacket message, List <object> output)
        {
            int         payloadBufferSize     = message.ReturnCodes.Count;
            int         variablePartSize      = PacketIdLength + payloadBufferSize;
            int         fixedHeaderBufferSize = 1 + MaxVariableLength;
            IByteBuffer buf = null;

            try
            {
                buf = bufferAllocator.Buffer(fixedHeaderBufferSize + variablePartSize);
                buf.WriteByte(CalculateFirstByteOfFixedHeader(message));
                WriteVariableLengthInt(buf, variablePartSize);
                buf.WriteShort(message.PacketId);
                foreach (QualityOfService qos in message.ReturnCodes)
                {
                    buf.WriteByte((byte)qos);
                }

                output.Add(buf);
                buf = null;
            }
            finally
            {
                buf?.SafeRelease();
            }
        }
コード例 #4
0
 public MessageFrameBuilder(IByteBufferAllocator alloc, int opcode, FrameType type)
 {
     Alloc  = alloc;
     Buffer = alloc.Buffer();
     OpCode = opcode;
     Type   = type;
 }
コード例 #5
0
        public IByteBuffer ReadChunk(IByteBufferAllocator allocator)
        {
            if (this.IsEndOfInput)
            {
                return(null);
            }

            long availableBytes = this.input.Length - this.input.Position;
            int  readChunkSize  = availableBytes <= 0L
                ? this.chunkSize
                : (int)Math.Min(this.chunkSize, availableBytes);

            bool        release = true;
            IByteBuffer buffer  = allocator.Buffer(readChunkSize);

            try
            {
                // transfer to buffer
                int count = buffer.SetBytesAsync(buffer.WriterIndex, this.input, readChunkSize, CancellationToken.None).Result;
                buffer.SetWriterIndex(buffer.WriterIndex + count);
                this.offset += count;

                release = false;
            }
            finally
            {
                if (release)
                {
                    buffer.Release();
                }
            }

            return(buffer);
        }
コード例 #6
0
ファイル: RpcMessageCodec.cs プロジェクト: egmkang/koala
        public object Encode(IByteBufferAllocator allocator, object message)
        {
            var msg         = message as RpcMessage;
            var name        = GetNameBytes(msg.Meta.GetType());
            var meta        = GetMsgJsonBytes(msg.Meta);
            var metaLength  = 1 + name.Length + meta.Length;
            var bodyLength  = msg.Body != null ? msg.Body.Length : 0;
            var totalLength = HeaderLength + metaLength + bodyLength;

            var buffer = allocator.Buffer(totalLength);

            buffer.WriteIntLE(Magic);
            buffer.WriteIntLE(metaLength);
            buffer.WriteIntLE(bodyLength);

            // 1字节NameLength + Name + M字节Meta
            buffer.WriteByte(name.Length);
            buffer.WriteBytes(name);
            buffer.WriteBytes(meta);

            if (msg.Body != null && msg.Body.Length > 0)
            {
                buffer.WriteBytes(msg.Body);
            }

            return(buffer);
        }
コード例 #7
0
        static IByteBuffer EncodeString0(IByteBufferAllocator alloc, string src, Encoding encoding, int extraCapacity)
        {
            int  length  = encoding.GetMaxByteCount(src.Length) + extraCapacity;
            bool release = true;

            IByteBuffer dst = alloc.Buffer(length);

            Contract.Assert(dst.HasArray, "Operation expects allocator to operate array-based buffers.");

            try
            {
                int written = encoding.GetBytes(src, 0, src.Length, dst.Array, dst.ArrayOffset + dst.WriterIndex);
                dst.SetWriterIndex(dst.WriterIndex + written);
                release = false;

                return(dst);
            }
            finally
            {
                if (release)
                {
                    dst.Release();
                }
            }
        }
コード例 #8
0
        public void Encrypt(IByteBufferAllocator allocator, EncryptMode mode, Stream src, Stream dst, bool reliable)
        {
            using (var data = new BufferWrapper(allocator.Buffer().WithOrder(ByteOrder.LittleEndian)))
                using (var encryptor = GetAlgorithm(mode).CreateEncryptor())
                    using (var cs = new CryptoStream(new NonClosingStream(dst), encryptor, CryptoStreamMode.Write))
                        using (var w = cs.ToBinaryWriter(false))
                        {
                            var blockSize = AES.BlockSize / 8;
                            var padding   = blockSize - (src.Length + 1 + 4) % blockSize;
                            if (reliable)
                            {
                                padding = blockSize - (src.Length + 1 + 4 + 2) % blockSize;
                            }

                            if (reliable)
                            {
                                var counter = (ushort)(Interlocked.Increment(ref _encryptCounter) - 1);
                                data.Buffer.WriteShort(counter);
                            }

                            using (var dataStream = new WriteOnlyByteBufferStream(data.Buffer, false))
                                src.CopyTo(dataStream);

                            w.Write((byte)padding);
                            using (var dataStream = new ReadOnlyByteBufferStream(data.Buffer, false))
                            {
                                w.Write(Hash.GetUInt32 <CRC32>(dataStream));
                                dataStream.Position = 0;
                                dataStream.CopyTo(cs);
                            }
                            w.Fill((int)padding);
                        }
        }
コード例 #9
0
        void WriteArrayHeader(IByteBufferAllocator allocator, long?length, ICollection <object> output)
        {
            Contract.Requires(allocator != null);
            Contract.Requires(output != null);

            IByteBuffer buffer = allocator.Buffer(
                RedisConstants.TypeLength
                + (!length.HasValue ? RedisConstants.NullLength : RedisConstants.LongValueMaximumLength)
                + RedisConstants.EndOfLineLength);

            buffer.WriteByte((char)RedisMessageType.ArrayHeader);

            if (!length.HasValue)
            {
                buffer.WriteShort(RedisConstants.Null);
            }
            else
            {
                byte[] bytes = this.NumberToBytes(length.Value);
                buffer.WriteBytes(bytes);
            }

            buffer.WriteShort(RedisConstants.EndOfLine);
            output.Add(buffer);
        }
コード例 #10
0
        static void EncodePublishMessage(IByteBufferAllocator bufferAllocator, PublishPacket packet, List <object> output)
        {
            IByteBuffer payload = packet.Payload ?? Unpooled.Empty;

            string topicName = packet.TopicName;

            Util.ValidateTopicName(topicName);
            byte[] topicNameBytes = EncodeStringInUtf8(topicName);

            int variableHeaderBufferSize = StringSizeLength + topicNameBytes.Length +
                                           (packet.QualityOfService > QualityOfService.AtMostOnce ? PacketIdLength : 0);
            int payloadBufferSize     = payload.ReadableBytes;
            int variablePartSize      = variableHeaderBufferSize + payloadBufferSize;
            int fixedHeaderBufferSize = 1 + MaxVariableLength;

            IByteBuffer buf = bufferAllocator.Buffer(fixedHeaderBufferSize + variablePartSize);

            buf.WriteByte(CalculateFirstByteOfFixedHeader(packet));
            WriteVariableLengthInt(buf, variablePartSize);
            buf.WriteShort(topicNameBytes.Length);
            buf.WriteBytes(topicNameBytes);
            if (packet.QualityOfService > QualityOfService.AtMostOnce)
            {
                buf.WriteShort(packet.PacketId);
            }

            output.Add(buf);

            if (payload.IsReadable())
            {
                output.Add(payload.Retain());
            }
        }
コード例 #11
0
ファイル: HttpConversionUtil.cs プロジェクト: wxlonstar/Fenix
        /// <summary>
        /// Create a new object to contain the request data
        /// </summary>
        /// <param name="streamId">The stream associated with the request</param>
        /// <param name="http2Headers">The initial set of HTTP/2 headers to create the request with</param>
        /// <param name="alloc">The <see cref="IByteBufferAllocator"/> to use to generate the content of the message</param>
        /// <param name="validateHttpHeaders"><c>true</c> to validate HTTP headers in the http-codec
        /// <para><c>false</c> not to validate HTTP headers in the http-codec</para></param>
        /// <returns>A new request object which represents headers/data</returns>
        /// <exception cref="Http2Exception">see <see cref="AddHttp2ToHttpHeaders(int, IHttp2Headers, IFullHttpMessage, bool)"/></exception>
        public static IFullHttpRequest ToFullHttpRequest(int streamId, IHttp2Headers http2Headers, IByteBufferAllocator alloc,
                                                         bool validateHttpHeaders)
        {
            // HTTP/2 does not define a way to carry the version identifier that is included in the HTTP/1.1 request line.
            var method = http2Headers.Method;

            if (method is null)
            {
                ThrowHelper.ThrowArgumentNullException_MethodHeader();
            }
            var path = http2Headers.Path;

            if (path is null)
            {
                ThrowHelper.ThrowArgumentNullException_PathHeader();
            }
            var msg = new DefaultFullHttpRequest(DotNettyHttpVersion.Http11, HttpMethod.ValueOf(AsciiString.Of(method)),
                                                 path.ToString(), alloc.Buffer(), validateHttpHeaders);

            try
            {
                AddHttp2ToHttpHeaders(streamId, http2Headers, msg, false);
            }
            catch (Http2Exception)
            {
                _ = msg.Release();
                throw;
            }
            catch (Exception t)
            {
                _ = msg.Release();
                ThrowHelper.ThrowStreamError_Http2ToHttp1HeadersConversionError(streamId, t);
            }
            return(msg);
        }
コード例 #12
0
        internal static IByteBuffer EncodeString0(IByteBufferAllocator alloc, bool enforceHeap, string src, Encoding encoding, int extraCapacity)
        {
            int  length  = encoding.GetMaxByteCount(src.Length) + extraCapacity;
            bool release = true;

            IByteBuffer dst = enforceHeap ? alloc.HeapBuffer(length) : alloc.Buffer(length);

            Debug.Assert(dst.HasArray, "Operation expects allocator to operate array-based buffers.");

            try
            {
#if NETCOREAPP || NETSTANDARD_2_0_GREATER
                int written = encoding.GetBytes(src.AsSpan(), dst.FreeSpan);
#else
                int written = encoding.GetBytes(src, 0, src.Length, dst.Array, dst.ArrayOffset + dst.WriterIndex);
#endif
                dst.SetWriterIndex(dst.WriterIndex + written);
                release = false;

                return(dst);
            }
            finally
            {
                if (release)
                {
                    dst.Release();
                }
            }
        }
コード例 #13
0
ファイル: PacketEncoder.cs プロジェクト: cocosip/FluentSocket
        public static void DoEncode(IByteBufferAllocator bufferAllocator, Packet packet, List <object> output)
        {
            IByteBuffer buffer = bufferAllocator.Buffer();


            try
            {
                // 1 byte PacketType
                buffer.WriteByte((byte)packet.PacketType);
                // 4 byte Sequence
                buffer.WriteInt(packet.Sequence);

                if (packet is PingPacket pingPacket)
                {
                    buffer.WriteByte(pingPacket.PingCode);
                }
                else if (packet is PongPacket pongPacket)
                {
                    buffer.WriteByte(pongPacket.PongCode);
                }
                else if (packet is MessageReqPacket messageReqPacket)
                {
                    buffer.WriteShort(messageReqPacket.Code);
                    buffer.WriteInt(messageReqPacket.Body.Length);
                    buffer.WriteBytes(messageReqPacket.Body);
                }
                else if (packet is MessageRespPacket messageRespPacket)
                {
                    buffer.WriteShort(messageRespPacket.Code);
                    buffer.WriteInt(messageRespPacket.Body.Length);
                    buffer.WriteBytes(messageRespPacket.Body);
                }
                else if (packet is PushReqPacket pushReqPacket)
                {
                    buffer.WriteByte((byte)pushReqPacket.PushType);
                    buffer.WriteShort(pushReqPacket.Code);
                    buffer.WriteInt(pushReqPacket.Body.Length);
                    buffer.WriteBytes(pushReqPacket.Body);
                }
                else if (packet is PushRespPacket pushRespPacket)
                {
                    buffer.WriteByte((byte)pushRespPacket.PushType);
                    buffer.WriteShort(pushRespPacket.Code);
                    buffer.WriteInt(pushRespPacket.Body.Length);
                    buffer.WriteBytes(pushRespPacket.Body);
                }
                else
                {
                    throw new ArgumentException("Invalid packet!");
                }

                output.Add(buffer);
                buffer = null;
            }
            finally
            {
                buffer?.SafeRelease();
            }
        }
コード例 #14
0
        public static IByteBuffer WriteAscii(IByteBufferAllocator alloc, string value)
        {
            // ASCII uses 1 byte per char
            IByteBuffer buf = alloc.Buffer(value.Length);

            _ = WriteAscii(buf, value);
            return(buf);
        }
コード例 #15
0
        public static IByteBuffer WriteAscii(IByteBufferAllocator alloc, ICharSequence seq)
        {
            // ASCII uses 1 byte per char
            IByteBuffer buf = alloc.Buffer(seq.Count);

            _ = WriteAscii(buf, seq);
            return(buf);
        }
コード例 #16
0
 static void WriteBulkStringContent(IByteBufferAllocator allocator, IBulkStringRedisContent msg, List <object> output)
 {
     output.Add(msg.Content.Retain());
     if (msg is ILastBulkStringRedisContent)
     {
         output.Add(allocator.Buffer(RedisConstants.EndOfLineLength).WriteShort(RedisConstants.EndOfLineShort));
     }
 }
コード例 #17
0
        public static IByteBuffer WriteUtf8(IByteBufferAllocator alloc, string value)
        {
            // UTF-8 uses max. 3 bytes per char, so calculate the worst case.
            IByteBuffer buf = alloc.Buffer(Utf8MaxBytes(value));

            WriteUtf8(buf, value);
            return(buf);
        }
コード例 #18
0
        public static IByteBuffer WriteUtf8(IByteBufferAllocator alloc, ICharSequence seq)
        {
            // UTF-8 uses max. 3 bytes per char, so calculate the worst case.
            IByteBuffer buf = alloc.Buffer(Utf8MaxBytes(seq));

            WriteUtf8(buf, seq);
            return(buf);
        }
コード例 #19
0
        static void EncodePacketWithFixedHeaderOnly(IByteBufferAllocator bufferAllocator, Packet packet, List <object> output)
        {
            IByteBuffer buffer = bufferAllocator.Buffer(2);

            buffer.WriteByte(CalculateFirstByteOfFixedHeader(packet));
            buffer.WriteByte(0);

            output.Add(buffer);
        }
コード例 #20
0
        public static IByteBuffer WriteUtf8(IByteBufferAllocator alloc, ICharSequence seq)
        {
            // UTF-8 uses max. 3 bytes per char, so calculate the worst case.
            var         maxByteCount = Utf8MaxBytes(seq);
            IByteBuffer buf          = alloc.Buffer(maxByteCount);

            _ = ReserveAndWriteUtf8(buf, seq, maxByteCount);
            return(buf);
        }
コード例 #21
0
        internal static IByteBuffer expandCumulation(IByteBufferAllocator alloc, IByteBuffer cumulation, int readable)
        {
            IByteBuffer oldCumulation = cumulation;

            cumulation = alloc.Buffer(oldCumulation.ReadableBytes + readable);
            cumulation.WriteBytes(oldCumulation);
            oldCumulation.Release();
            return(cumulation);
        }
コード例 #22
0
        void WriteIntegerMessage(IByteBufferAllocator allocator, IntegerRedisMessage msg, List <object> output)
        {
            IByteBuffer buf = allocator.Buffer(RedisConstants.TypeLength + RedisConstants.LongMaxLength +
                                               RedisConstants.EndOfLineLength);

            RedisMessageType.Integer.WriteTo(buf);
            buf.WriteBytes(this.NumberToBytes(msg.Value));
            buf.WriteShort(RedisConstants.EndOfLineShort);
            output.Add(buf);
        }
コード例 #23
0
        static void WriteString(IByteBufferAllocator allocator, RedisMessageType type, string content, List <object> output)
        {
            IByteBuffer buf = allocator.Buffer(type.Length + ByteBufferUtil.Utf8MaxBytes(content) +
                                               RedisConstants.EndOfLineLength);

            type.WriteTo(buf);
            ByteBufferUtil.WriteUtf8(buf, content);
            buf.WriteShort(RedisConstants.EndOfLineShort);
            output.Add(buf);
        }
コード例 #24
0
 public IFullHttpMessage CopyIfNeeded(IByteBufferAllocator allocator, IFullHttpMessage msg)
 {
     if (msg is IFullHttpRequest request)
     {
         var copy = (IFullHttpRequest)request.Replace(allocator.Buffer(0));
         _ = copy.Headers.Remove(HttpHeaderNames.Expect);
         return(copy);
     }
     return(null);
 }
コード例 #25
0
            /// <summary>
            /// Adds a fragment to the block.
            /// </summary>
            /// <param name="fragment">the fragment of the headers block to be added.</param>
            /// <param name="len"></param>
            /// <param name="alloc">allocator for new blocks if needed.</param>
            /// <param name="endOfHeaders">flag indicating whether the current frame is the end of the headers.
            /// This is used for an optimization for when the first fragment is the full
            /// block. In that case, the buffer is used directly without copying.</param>
            internal void AddFragment(IByteBuffer fragment, int len, IByteBufferAllocator alloc, bool endOfHeaders)
            {
                if (_headerBlock is null)
                {
                    if (len > _reader._headersDecoder.Configuration.MaxHeaderListSizeGoAway)
                    {
                        HeaderSizeExceeded();
                    }

                    if (endOfHeaders)
                    {
                        // Optimization - don't bother copying, just use the buffer as-is. Need
                        // to retain since we release when the header block is built.
                        _headerBlock = fragment.ReadRetainedSlice(len);
                    }
                    else
                    {
                        _headerBlock = alloc.Buffer(len).WriteBytes(fragment, len);
                    }
                    return;
                }

                if (_reader._headersDecoder.Configuration.MaxHeaderListSizeGoAway - len < _headerBlock.ReadableBytes)
                {
                    HeaderSizeExceeded();
                }

                if (_headerBlock.IsWritable(len))
                {
                    // The buffer can hold the requested bytes, just write it directly.
                    _ = _headerBlock.WriteBytes(fragment, len);
                }
                else
                {
                    // Allocate a new buffer that is big enough to hold the entire header block so far.
                    IByteBuffer buf = alloc.Buffer(_headerBlock.ReadableBytes + len);
                    _            = buf.WriteBytes(_headerBlock).WriteBytes(fragment, len);
                    _            = _headerBlock.Release();
                    _headerBlock = buf;
                }
            }
コード例 #26
0
        static void EncodePublishMessage(IByteBufferAllocator bufferAllocator, PublishPacket packet, List <object> output)
        {
            //IByteBuffer payload = packet.Payload ?? Unpooled.Empty;
            IByteBuffer payload;

            if (packet.Payload == null)
            {
                payload = Unpooled.Empty;
            }
            else
            {
                payload = Unpooled.Buffer();
                payload.WriteBytes(packet.Payload);
            }

            string topicName = packet.TopicName;

            Util.ValidateTopicName(topicName);
            byte[] topicNameBytes = EncodeStringInUtf8(topicName);

            int variableHeaderBufferSize = StringSizeLength + topicNameBytes.Length +
                                           (packet.Qos > MqttQos.AtMostOnce ? PacketIdLength : 0);
            int payloadBufferSize     = payload.ReadableBytes;
            int variablePartSize      = variableHeaderBufferSize + payloadBufferSize;
            int fixedHeaderBufferSize = 1 + MaxVariableLength;

            IByteBuffer buf = null;

            try
            {
                buf = bufferAllocator.Buffer(fixedHeaderBufferSize + variablePartSize);
                buf.WriteByte(CalculateFirstByteOfFixedHeader(packet));
                WriteVariableLengthInt(buf, variablePartSize);
                buf.WriteShort(topicNameBytes.Length);
                buf.WriteBytes(topicNameBytes);
                if (packet.Qos > MqttQos.AtMostOnce)
                {
                    buf.WriteShort(packet.PacketId);
                }

                output.Add(buf);
                buf = null;
            }
            finally
            {
                buf?.SafeRelease();
            }

            if (payload.IsReadable())
            {
                output.Add(payload.Retain());
            }
        }
コード例 #27
0
 void WriteArrayHeader(IByteBufferAllocator allocator, bool isNull, long length, List <object> output)
 {
     if (isNull)
     {
         IByteBuffer buf = allocator.Buffer(RedisConstants.TypeLength + RedisConstants.NullLength +
                                            RedisConstants.EndOfLineLength);
         RedisMessageType.ArrayHeader.WriteTo(buf);
         buf.WriteShort(RedisConstants.NullShort);
         buf.WriteShort(RedisConstants.EndOfLineShort);
         output.Add(buf);
     }
     else
     {
         IByteBuffer buf = allocator.Buffer(RedisConstants.TypeLength + RedisConstants.LongMaxLength +
                                            RedisConstants.EndOfLineLength);
         RedisMessageType.ArrayHeader.WriteTo(buf);
         buf.WriteBytes(this.NumberToBytes(length));
         buf.WriteShort(RedisConstants.EndOfLineShort);
         output.Add(buf);
     }
 }
コード例 #28
0
        public IByteBuffer Buffer(int initialCapacity, int maxCapacity)
        {
            // If the capacity values are negative then clamp them at zero.
            initialCapacity = initialCapacity >= 0 ? initialCapacity : 0;
            maxCapacity     = maxCapacity >= 0 ? maxCapacity : 0;

            Debug.Assert(initialCapacity >= 0);
            Debug.Assert(maxCapacity >= 0);

            if (initialCapacity == 0 && maxCapacity == 0)
            {
                return(DelegateAllocator.Buffer(0, 0)); // Will returned a reusable EmptyBuffer.
            }

            // If the capacity values, after adding padding, are too large then clamp them at int.MaxValue.
            long maxCapLong  = (long)maxCapacity + BufferFrontPadding;
            long initCapLong = (long)initialCapacity + BufferFrontPadding;

            var clampedMaxCapacity     = maxCapLong > int.MaxValue ? int.MaxValue : (int)maxCapLong;
            var clampedInitialCapacity = initCapLong > int.MaxValue ? int.MaxValue : (int)initCapLong;

            Debug.Assert(clampedMaxCapacity >= 0 && clampedMaxCapacity <= int.MaxValue);
            Debug.Assert(clampedInitialCapacity >= 0 && clampedInitialCapacity <= int.MaxValue);

            // Allocate the buffer, and write the padding mask in the padding section
            // so that it's easy to see it when debugging.
            var buffer                  = DelegateAllocator.Buffer(clampedInitialCapacity, clampedMaxCapacity);
            var writerIndex             = buffer.WriterIndex;
            var writerIndexAfterPadding = writerIndex + BufferFrontPadding;

            buffer.SetInt(writerIndex, PaddingMask);

            buffer.SetWriterIndex(writerIndexAfterPadding);
            buffer.MarkWriterIndex();

            buffer.SetReaderIndex(writerIndexAfterPadding);
            buffer.MarkReaderIndex();

            return(buffer);
        }
コード例 #29
0
        public void BufferWithCapacity(bool preferDirect, int maxCapacity)
        {
            IByteBufferAllocator allocator = this.NewAllocator(preferDirect);
            IByteBuffer          buffer    = allocator.Buffer(1, maxCapacity);

            try
            {
                AssertBuffer(buffer, this.IsDirectExpected(preferDirect), 1, maxCapacity);
            }
            finally
            {
                buffer.Release();
            }
        }
コード例 #30
0
        public void BufferWithCapacity()
        {
            IByteBufferAllocator allocator = this.NewAllocator();
            IByteBuffer          buffer    = allocator.Buffer(1, 8);

            try
            {
                AssertBuffer(buffer, 1, 8);
            }
            finally
            {
                buffer.Release();
            }
        }
コード例 #31
0
 static IByteBuffer ExpandCumulation(IByteBufferAllocator allocator, IByteBuffer cumulation, int readable)
 {
     IByteBuffer oldCumulation = cumulation;
     cumulation = allocator.Buffer(oldCumulation.ReadableBytes + readable);
     cumulation.WriteBytes(oldCumulation);
     oldCumulation.Release();
     return cumulation;
 }
コード例 #32
0
        public static async Task<PublishPacket> ComposePublishPacketAsync(IChannelHandlerContext context, IMessage message,
            QualityOfService qos, string topicName, IByteBufferAllocator allocator)
        {
            bool duplicate = message.DeliveryCount > 0;

            var packet = new PublishPacket(qos, duplicate, false);
            packet.TopicName = topicName;
            if (qos > QualityOfService.AtMostOnce)
            {
                int packetId = unchecked((int)message.SequenceNumber) & 0x3FFF; // clear bits #14 and #15
                switch (qos)
                {
                    case QualityOfService.AtLeastOnce:
                        break;
                    case QualityOfService.ExactlyOnce:
                        packetId |= 0x8000; // set bit #15
                        break;
                    default:
                        throw new ArgumentOutOfRangeException(nameof(qos), qos, null);
                }
                packet.PacketId = packetId + 1;
            }
            using (Stream payloadStream = message.Payload)
            {
                long streamLength = payloadStream.Length;
                if (streamLength > int.MaxValue)
                {
                    throw new InvalidOperationException($"Message size ({streamLength} bytes) is too big to process.");
                }

                int length = (int)streamLength;
                IByteBuffer buffer = allocator.Buffer(length, length);
                await buffer.WriteBytesAsync(payloadStream, length);
                Contract.Assert(buffer.ReadableBytes == length);

                packet.Payload = buffer;
            }
            return packet;
        }
コード例 #33
0
 public IByteBuffer Allocate(IByteBufferAllocator alloc) => alloc.Buffer(this.bufferSize);
コード例 #34
0
 public IByteBuffer Allocate(IByteBufferAllocator alloc)
 {
     return alloc.Buffer(this.bufferSize);
 }
コード例 #35
0
ファイル: ByteBufferUtil.cs プロジェクト: RabbitTeam/DotNetty
        static IByteBuffer EncodeString0(IByteBufferAllocator alloc, string src, Encoding encoding, int extraCapacity)
        {
            int length = encoding.GetMaxByteCount(src.Length) + extraCapacity;
            bool release = true;

            IByteBuffer dst = alloc.Buffer(length);
            Contract.Assert(dst.HasArray, "Operation expects allocator to operate array-based buffers.");

            try
            {
                int written = encoding.GetBytes(src, 0, src.Length, dst.Array, dst.ArrayOffset + dst.WriterIndex);
                dst.SetWriterIndex(dst.WriterIndex + written);
                release = false;

                return dst;
            }
            finally
            {
                if (release)
                {
                    dst.Release();
                }
            }
        }
コード例 #36
0
ファイル: ByteBufferUtil.cs プロジェクト: donmikel/DotNetty
 /// <summary>
 /// Read the given amount of bytes into a new {@link ByteBuf} that is allocated from the {@link ByteBufAllocator}.
 /// </summary>
 public static IByteBuffer ReadBytes(IByteBufferAllocator alloc, IByteBuffer buffer, int length)
 {
     bool release = true;
     IByteBuffer dst = alloc.Buffer(length);
     try
     {
         buffer.ReadBytes(dst);
         release = false;
         return dst;
     }
     finally
     {
         if (release)
         {
             dst.Release();
         }
     }
 }