public void ReferenceCounts3() { IByteBuffer c1 = Unpooled.Buffer().WriteByte(1); var c2 = (IByteBuffer)Unpooled.Buffer().WriteByte(2).Retain(); var c3 = (IByteBuffer)Unpooled.Buffer().WriteByte(3).Retain(2); CompositeByteBuffer buf = Unpooled.CompositeBuffer(); Assert.Equal(1, buf.ReferenceCount); var components = new List <IByteBuffer> { c1, c2, c3 }; buf.AddComponents(components); // Ensure that c[123]'s refCount did not change. Assert.Equal(1, c1.ReferenceCount); Assert.Equal(2, c2.ReferenceCount); Assert.Equal(3, c3.ReferenceCount); Assert.Equal(1, buf[0].ReferenceCount); Assert.Equal(2, buf[1].ReferenceCount); Assert.Equal(3, buf[2].ReferenceCount); c3.Release(2); c2.Release(); buf.Release(); }
public void DuplicateEmpty() { CompositeByteBuffer buf = Unpooled.CompositeBuffer(); Assert.Equal(0, buf.NumComponents); Assert.Equal(0, buf.Duplicate().ReadableBytes); buf.Release(); }
private IByteBuffer CompressContent(IChannelHandlerContext ctx, WebSocketFrame msg) { if (_encoder is null) { _encoder = new EmbeddedChannel( ZlibCodecFactory.NewZlibEncoder( ZlibWrapper.None, _compressionLevel, _windowSize, 8)); } _ = _encoder.WriteOutbound(msg.Content.Retain()); CompositeByteBuffer fullCompressedContent = ctx.Allocator.CompositeBuffer(); while (true) { var partCompressedContent = _encoder.ReadOutbound <IByteBuffer>(); if (partCompressedContent is null) { break; } if (!partCompressedContent.IsReadable()) { _ = partCompressedContent.Release(); continue; } _ = fullCompressedContent.AddComponent(true, partCompressedContent); } if (fullCompressedContent.NumComponents <= 0) { _ = fullCompressedContent.Release(); ThrowHelper.ThrowCodecException_CannotReadCompressedBuf(); } if (msg.IsFinalFragment && _noContext) { Cleanup(); } IByteBuffer compressedContent; if (RemoveFrameTail(msg)) { int realLength = fullCompressedContent.ReadableBytes - FrameTail.ReadableBytes; compressedContent = fullCompressedContent.Slice(0, realLength); } else { compressedContent = fullCompressedContent; } return(compressedContent); }
public void RemoveLastComponent() { CompositeByteBuffer buf = Unpooled.CompositeBuffer(); buf.AddComponent(Unpooled.WrappedBuffer(new byte[] { 1, 2 })); Assert.Equal(1, buf.NumComponents); buf.RemoveComponent(0); Assert.Equal(0, buf.NumComponents); buf.Release(); }
public void ComponentMustBeDuplicate() { CompositeByteBuffer buf = Unpooled.CompositeBuffer(); buf.AddComponent(Unpooled.Buffer(4, 6).SetIndex(1, 3)); Assert.IsAssignableFrom <AbstractDerivedByteBuffer>(buf[0]); Assert.Equal(4, buf[0].Capacity); Assert.Equal(6, buf[0].MaxCapacity); Assert.Equal(2, buf[0].ReadableBytes); buf.Release(); }
public void AddEmptyBufferRelease() { CompositeByteBuffer cbuf = Unpooled.CompositeBuffer(); IByteBuffer buf = Unpooled.Buffer(); Assert.Equal(1, buf.ReferenceCount); cbuf.AddComponent(buf); Assert.Equal(1, buf.ReferenceCount); cbuf.Release(); Assert.Equal(0, buf.ReferenceCount); }
public void CopyEmpty() { CompositeByteBuffer buf = Unpooled.CompositeBuffer(); Assert.Equal(0, buf.NumComponents); IByteBuffer copy = buf.Copy(); Assert.Equal(0, copy.ReadableBytes); buf.Release(); copy.Release(); }
public void CompositeHeapBufferWithCapacity() { IByteBufferAllocator allocator = this.NewAllocator(); CompositeByteBuffer buffer = allocator.CompositeHeapBuffer(8); try { this.AssertCompositeByteBuffer(buffer, 8); } finally { buffer.Release(); } }
public void CompositeDirectBuffer(bool preferDirect) { IByteBufferAllocator allocator = this.NewAllocator(preferDirect); CompositeByteBuffer buffer = allocator.CompositeDirectBuffer(); try { this.AssertCompositeByteBuffer(buffer, this.DefaultMaxComponents); } finally { buffer.Release(); } }
public void CompositeDirectBufferWithCapacity(bool preferDirect, int maxNumComponents) { IByteBufferAllocator allocator = this.NewAllocator(preferDirect); CompositeByteBuffer buffer = allocator.CompositeDirectBuffer(maxNumComponents); try { this.AssertCompositeByteBuffer(buffer, maxNumComponents); } finally { buffer.Release(); } }
public void NestedLayout() { CompositeByteBuffer buf = Unpooled.CompositeBuffer(); buf.AddComponent( Unpooled.CompositeBuffer() .AddComponent(Unpooled.WrappedBuffer(new byte[] { 1, 2 })) .AddComponent(Unpooled.WrappedBuffer(new byte[] { 3, 4 })).Slice(1, 2)); ArraySegment <byte>[] nioBuffers = buf.GetIoBuffers(0, 2); Assert.Equal(2, nioBuffers.Length); Assert.Equal((byte)2, nioBuffers[0].Array[nioBuffers[0].Offset]); Assert.Equal((byte)3, nioBuffers[1].Array[nioBuffers[1].Offset]); buf.Release(); }
public void FullConsolidation() { CompositeByteBuffer buf = Unpooled.CompositeBuffer(int.MaxValue); buf.AddComponent(Unpooled.WrappedBuffer(new byte[] { 1 })); buf.AddComponent(Unpooled.WrappedBuffer(new byte[] { 2, 3 })); buf.AddComponent(Unpooled.WrappedBuffer(new byte[] { 4, 5, 6 })); buf.Consolidate(); Assert.Equal(1, buf.NumComponents); Assert.True(buf.HasArray); Assert.NotNull(buf.Array); Assert.Equal(0, buf.ArrayOffset); buf.Release(); }
public void RangedConsolidation() { CompositeByteBuffer buf = Unpooled.CompositeBuffer(int.MaxValue); buf.AddComponent(Unpooled.WrappedBuffer(new byte[] { 1 })); buf.AddComponent(Unpooled.WrappedBuffer(new byte[] { 2, 3 })); buf.AddComponent(Unpooled.WrappedBuffer(new byte[] { 4, 5, 6 })); buf.AddComponent(Unpooled.WrappedBuffer(new byte[] { 7, 8, 9, 10 })); buf.Consolidate(1, 2); Assert.Equal(3, buf.NumComponents); Assert.Equal(Unpooled.WrappedBuffer(new byte[] { 1 }), buf[0]); Assert.Equal(Unpooled.WrappedBuffer(new byte[] { 2, 3, 4, 5, 6 }), buf[1]); Assert.Equal(Unpooled.WrappedBuffer(new byte[] { 7, 8, 9, 10 }), buf[2]); buf.Release(); }
public void ForEachByteUnderLeakDetectionShouldNotThrowException() { CompositeByteBuffer buf = (CompositeByteBuffer)NewBuffer(8); Assert.True(buf is SimpleLeakAwareCompositeByteBuffer); CompositeByteBuffer comp = (CompositeByteBuffer)NewBuffer(8); Assert.True(comp is SimpleLeakAwareCompositeByteBuffer); IByteBuffer inner = comp.Allocator.DirectBuffer(1).WriteByte(0); comp.AddComponent(true, inner); buf.AddComponent(true, comp); Assert.Equal(-1, buf.ForEachByte(new AlwaysByteProcessor())); Assert.True(buf.Release()); }
public void AddEmptyBufferInMiddle() { CompositeByteBuffer cbuf = Unpooled.CompositeBuffer(); IByteBuffer buf1 = Unpooled.Buffer().WriteByte(1); cbuf.AddComponent(true, buf1); cbuf.AddComponent(true, Unpooled.Empty); IByteBuffer buf3 = Unpooled.Buffer().WriteByte(2); cbuf.AddComponent(true, buf3); Assert.Equal(2, cbuf.ReadableBytes); Assert.Equal((byte)1, cbuf.ReadByte()); Assert.Equal((byte)2, cbuf.ReadByte()); Assert.Same(Unpooled.Empty, cbuf.InternalComponent(1)); Assert.NotSame(Unpooled.Empty, cbuf.InternalComponentAtOffset(1)); cbuf.Release(); }
public IByteBuffer Cumulate(IByteBufferAllocator alloc, IByteBuffer cumulation, IByteBuffer input) { if (!cumulation.IsReadable()) { _ = cumulation.Release(); return(input); } CompositeByteBuffer composite = null; try { composite = cumulation as CompositeByteBuffer; if (composite is object && 0u >= (uint)(cumulation.ReferenceCount - 1)) { // Writer index must equal capacity if we are going to "write" // new components to the end if (composite.WriterIndex != composite.Capacity) { _ = composite.AdjustCapacity(composite.WriterIndex); } } else { composite = alloc.CompositeBuffer(int.MaxValue).AddFlattenedComponents(true, cumulation); } _ = composite.AddFlattenedComponents(true, input); input = null; return(composite); } finally { if (input is object) { // We must release if the ownership was not transferred as otherwise it may produce a leak _ = input.Release(); // Also release any new buffer allocated if we're not returning it if (composite is object && composite != cumulation) { _ = composite.Release(); } } } }
public void AddEmptyBuffersRelease() { CompositeByteBuffer cbuf = Unpooled.CompositeBuffer(); IByteBuffer buf = Unpooled.Buffer(); IByteBuffer buf2 = Unpooled.Buffer().WriteInt(1); IByteBuffer buf3 = Unpooled.Buffer(); Assert.Equal(1, buf.ReferenceCount); Assert.Equal(1, buf2.ReferenceCount); Assert.Equal(1, buf3.ReferenceCount); cbuf.AddComponents(buf, buf2, buf3); Assert.Equal(1, buf.ReferenceCount); Assert.Equal(1, buf2.ReferenceCount); Assert.Equal(1, buf3.ReferenceCount); cbuf.Release(); Assert.Equal(0, buf.ReferenceCount); Assert.Equal(0, buf2.ReferenceCount); Assert.Equal(0, buf3.ReferenceCount); }
public void DiscardSomeReadBytes() { CompositeByteBuffer cbuf = Unpooled.CompositeBuffer(); int len = 8 * 4; for (int i = 0; i < len; i += 4) { IByteBuffer buf = Unpooled.Buffer().WriteInt(i); cbuf.AdjustCapacity(cbuf.WriterIndex); cbuf.AddComponent(buf).SetWriterIndex(i + 4); } cbuf.WriteByte(1); var me = new byte[len]; cbuf.ReadBytes(me); cbuf.ReadByte(); cbuf.DiscardSomeReadBytes(); cbuf.Release(); }
public void CompositeToSingleBuffer() { CompositeByteBuffer buf = Unpooled.CompositeBuffer(3); buf.AddComponent(Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 })); Assert.Equal(1, buf.NumComponents); buf.AddComponent(Unpooled.WrappedBuffer(new byte[] { 4 })); Assert.Equal(2, buf.NumComponents); buf.AddComponent(Unpooled.WrappedBuffer(new byte[] { 5, 6 })); Assert.Equal(3, buf.NumComponents); // NOTE: hard-coding 6 here, since it seems like addComponent doesn't bump the writer index. // I'm unsure as to whether or not this is correct behavior ArraySegment <byte> nioBuffer = buf.GetIoBuffer(0, 6); Assert.Equal(6, nioBuffer.Count); Assert.True(nioBuffer.Array.SequenceEqual(new byte[] { 1, 2, 3, 4, 5, 6 })); buf.Release(); }
public void ReferenceCounts2() { IByteBuffer c1 = Unpooled.Buffer().WriteByte(1); var c2 = (IByteBuffer)Unpooled.Buffer().WriteByte(2).Retain(); var c3 = (IByteBuffer)Unpooled.Buffer().WriteByte(3).Retain(2); CompositeByteBuffer bufA = Unpooled.CompositeBuffer(); bufA.AddComponents(c1, c2, c3).SetWriterIndex(3); CompositeByteBuffer bufB = Unpooled.CompositeBuffer(); bufB.AddComponents((IByteBuffer)bufA); // Ensure that bufA.refCnt() did not change. Assert.Equal(1, bufA.ReferenceCount); // Ensure that c[123]'s refCnt did not change. Assert.Equal(1, c1.ReferenceCount); Assert.Equal(2, c2.ReferenceCount); Assert.Equal(3, c3.ReferenceCount); // This should decrease bufA.refCnt(). bufB.Release(); Assert.Equal(0, bufB.ReferenceCount); // Ensure bufA.refCnt() changed. Assert.Equal(0, bufA.ReferenceCount); // Ensure that c[123]'s refCnt also changed due to the deallocation of bufA. Assert.Equal(0, c1.ReferenceCount); Assert.Equal(1, c2.ReferenceCount); Assert.Equal(2, c3.ReferenceCount); c3.Release(2); c2.Release(); }
protected internal override void Decode(IChannelHandlerContext ctx, WebSocketFrame msg, List <object> output) { if (this.decoder == null) { if (!(msg is TextWebSocketFrame) && !(msg is BinaryWebSocketFrame)) { throw new CodecException($"unexpected initial frame type: {msg.GetType().Name}"); } this.decoder = new EmbeddedChannel(ZlibCodecFactory.NewZlibDecoder(ZlibWrapper.None)); } bool readable = msg.Content.IsReadable(); this.decoder.WriteInbound(msg.Content.Retain()); if (this.AppendFrameTail(msg)) { this.decoder.WriteInbound(Unpooled.WrappedBuffer(FrameTail)); } CompositeByteBuffer compositeUncompressedContent = ctx.Allocator.CompositeDirectBuffer(); for (;;) { var partUncompressedContent = this.decoder.ReadInbound <IByteBuffer>(); if (partUncompressedContent == null) { break; } if (!partUncompressedContent.IsReadable()) { partUncompressedContent.Release(); continue; } compositeUncompressedContent.AddComponent(true, partUncompressedContent); } // Correctly handle empty frames // See https://github.com/netty/netty/issues/4348 if (readable && compositeUncompressedContent.NumComponents <= 0) { compositeUncompressedContent.Release(); throw new CodecException("cannot read uncompressed buffer"); } if (msg.IsFinalFragment && this.noContext) { this.Cleanup(); } WebSocketFrame outMsg; if (msg is TextWebSocketFrame) { outMsg = new TextWebSocketFrame(msg.IsFinalFragment, this.NewRsv(msg), compositeUncompressedContent); } else if (msg is BinaryWebSocketFrame) { outMsg = new BinaryWebSocketFrame(msg.IsFinalFragment, this.NewRsv(msg), compositeUncompressedContent); } else if (msg is ContinuationWebSocketFrame) { outMsg = new ContinuationWebSocketFrame(msg.IsFinalFragment, this.NewRsv(msg), compositeUncompressedContent); } else { throw new CodecException($"unexpected frame type: {msg.GetType().Name}"); } output.Add(outMsg); }
protected internal override void Encode(IChannelHandlerContext ctx, WebSocketFrame msg, List <object> output) { if (this.encoder == null) { this.encoder = new EmbeddedChannel( ZlibCodecFactory.NewZlibEncoder( ZlibWrapper.None, this.compressionLevel, this.windowSize, 8)); } this.encoder.WriteOutbound(msg.Content.Retain()); CompositeByteBuffer fullCompressedContent = ctx.Allocator.CompositeBuffer(); for (;;) { var partCompressedContent = this.encoder.ReadOutbound <IByteBuffer>(); if (partCompressedContent == null) { break; } if (!partCompressedContent.IsReadable()) { partCompressedContent.Release(); continue; } fullCompressedContent.AddComponent(true, partCompressedContent); } if (fullCompressedContent.NumComponents <= 0) { fullCompressedContent.Release(); throw new CodecException("cannot read compressed buffer"); } if (msg.IsFinalFragment && this.noContext) { this.Cleanup(); } IByteBuffer compressedContent; if (this.RemoveFrameTail(msg)) { int realLength = fullCompressedContent.ReadableBytes - FrameTail.Length; compressedContent = fullCompressedContent.Slice(0, realLength); } else { compressedContent = fullCompressedContent; } WebSocketFrame outMsg; if (msg is TextWebSocketFrame) { outMsg = new TextWebSocketFrame(msg.IsFinalFragment, this.Rsv(msg), compressedContent); } else if (msg is BinaryWebSocketFrame) { outMsg = new BinaryWebSocketFrame(msg.IsFinalFragment, this.Rsv(msg), compressedContent); } else if (msg is ContinuationWebSocketFrame) { outMsg = new ContinuationWebSocketFrame(msg.IsFinalFragment, this.Rsv(msg), compressedContent); } else { throw new CodecException($"unexpected frame type: {msg.GetType().Name}"); } output.Add(outMsg); }