public override void ChannelActive(IChannelHandlerContext ctx) { CompositeBufferPartialWriteDoesNotCorruptDataInitServerConfig(ctx.Channel.Configuration, _soSndBuf); // First single write int offset = _soSndBuf - 100; ctx.WriteAsync(_expectedContent.RetainedSlice(_expectedContent.ReaderIndex, offset)); // Build and write CompositeByteBuf CompositeByteBuffer compositeByteBuf = ctx.Allocator.CompositeBuffer(); compositeByteBuf.AddComponent(true, _expectedContent.RetainedSlice(_expectedContent.ReaderIndex + offset, 50)); offset += 50; compositeByteBuf.AddComponent(true, _expectedContent.RetainedSlice(_expectedContent.ReaderIndex + offset, 200)); offset += 200; ctx.WriteAsync(compositeByteBuf); // Write a single buffer that is smaller than the second component of the CompositeByteBuf // above but small enough to fit in the remaining space allowed by the soSndBuf amount. ctx.WriteAsync(_expectedContent.RetainedSlice(_expectedContent.ReaderIndex + offset, 50)); offset += 50; // Write the remainder of the content ctx.WriteAndFlushAsync(_expectedContent.RetainedSlice(_expectedContent.ReaderIndex + offset, _expectedContent.ReadableBytes - _expectedContent.ReaderIndex - offset)) .CloseOnComplete(ctx.Channel); }
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(); }
protected static CompositeByteBuffer ToLeakAwareBuffer(CompositeByteBuffer buf) { IResourceLeakTracker leak; switch (ResourceLeakDetector.Level) { case ResourceLeakDetector.DetectionLevel.Simple: leak = AbstractByteBuffer.LeakDetector.Track(buf); if (leak != null) { buf = new SimpleLeakAwareCompositeByteBuffer(buf, leak); } break; case ResourceLeakDetector.DetectionLevel.Advanced: case ResourceLeakDetector.DetectionLevel.Paranoid: leak = AbstractByteBuffer.LeakDetector.Track(buf); if (leak != null) { buf = new AdvancedLeakAwareCompositeByteBuffer(buf, leak); } break; case ResourceLeakDetector.DetectionLevel.Disabled: break; default: throw new ArgumentOutOfRangeException(); } return(buf); }
public void TestNioBuffersExpand2() { TestChannel channel = new TestChannel(); ChannelOutboundBuffer buffer = new ChannelOutboundBuffer(channel); CompositeByteBuffer comp = Unpooled.CompositeBuffer(256); IByteBuffer buf = Unpooled.DirectBuffer().WriteBytes(Encoding.ASCII.GetBytes("buf1")); for (int i = 0; i < 65; i++) { comp.AddComponent(true, buf.Copy()); } buffer.AddMessage(comp, comp.ReadableBytes, channel.VoidPromise()); Assert.Equal(0, buffer.NioBufferCount); // Should still be 0 as not flushed yet buffer.AddFlush(); var buffers = buffer.GetSharedBufferList(); Assert.Equal(65, buffer.NioBufferCount); for (int i = 0; i < buffer.NioBufferCount; i++) { if (i < 65) { Assert.Equal(buffers[i], buf.GetIoBuffer(buf.ReaderIndex, buf.ReadableBytes)); } else { Assert.Null(buffers[i].Array); } } Release(buffer); buf.Release(); }
public void TestNioBuffersMaxCount() { TestChannel channel = new TestChannel(); ChannelOutboundBuffer buffer = new ChannelOutboundBuffer(channel); CompositeByteBuffer comp = Unpooled.CompositeBuffer(256); IByteBuffer buf = Unpooled.DirectBuffer().WriteBytes(Encoding.ASCII.GetBytes("buf1")); for (int i = 0; i < 65; i++) { comp.AddComponent(true, buf.Copy()); } Assert.Equal(65, comp.IoBufferCount); buffer.AddMessage(comp, comp.ReadableBytes, channel.VoidPromise()); Assert.Equal(0, buffer.NioBufferCount); // Should still be 0 as not flushed yet buffer.AddFlush(); int maxCount = 10; // less than comp.nioBufferCount() var buffers = buffer.GetSharedBufferList(maxCount, int.MaxValue); Assert.True(buffer.NioBufferCount <= maxCount); // Should not be greater than maxCount for (int i = 0; i < buffer.NioBufferCount; i++) { Assert.Equal(buffers[i], buf.GetIoBuffer(buf.ReaderIndex, buf.ReadableBytes)); } Release(buffer); buf.Release(); }
protected sealed override IByteBuffer Wrap(CompositeByteBuffer buffer) { var tracker = new NoopResourceLeakTracker(); var leakAwareBuf = (WrappedCompositeByteBuffer)this.Wrap(buffer, tracker); this.trackers.Enqueue(tracker); return(leakAwareBuf); }
public void DuplicateEmpty() { CompositeByteBuffer buf = Unpooled.CompositeBuffer(); Assert.Equal(0, buf.NumComponents); Assert.Equal(0, buf.Duplicate().ReadableBytes); buf.Release(); }
public IByteBuffer ToByteBuffer() { CompositeByteBuffer compositeBuffer = ArrayPooled.CompositeBuffer(); _ = compositeBuffer.AddComponents(this.value); _ = compositeBuffer.SetWriterIndex(this.size); _ = compositeBuffer.SetReaderIndex(0); return compositeBuffer; }
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 Run(AddressBook addressBook, bool isCompositeBuffer) { var channel = new EmbeddedChannel( new ProtobufVarint32FrameDecoder(), new ProtobufDecoder(AddressBook.Parser), new ProtobufVarint32LengthFieldPrepender(), new ProtobufEncoder()); Assert.True(channel.WriteOutbound(addressBook)); var buffer = channel.ReadOutbound <IByteBuffer>(); Assert.NotNull(buffer); Assert.True(buffer.ReadableBytes > 0); var data = new byte[buffer.ReadableBytes]; buffer.ReadBytes(data); IByteBuffer inputBuffer; if (isCompositeBuffer) { inputBuffer = new CompositeByteBuffer(UnpooledByteBufferAllocator.Default, 2, Unpooled.CopiedBuffer(data, 0, 2), Unpooled.CopiedBuffer(data, 2, data.Length - 2)); } else { inputBuffer = Unpooled.WrappedBuffer(data); } Assert.True(channel.WriteInbound(inputBuffer)); var message = channel.ReadInbound <IMessage>(); Assert.NotNull(message); Assert.IsType <AddressBook>(message); var roundTripped = (AddressBook)message; Assert.Equal(addressBook.People.Count, roundTripped.People.Count); for (int i = 0; i < addressBook.People.Count; i++) { Assert.Equal(addressBook.People[i].Id, roundTripped.People[i].Id); Assert.Equal(addressBook.People[i].Email, roundTripped.People[i].Email); Assert.Equal(addressBook.People[i].Name, roundTripped.People[i].Name); Assert.Equal(addressBook.People[i].Phones.Count, roundTripped.People[i].Phones.Count); for (int j = 0; j < addressBook.People[i].Phones.Count; j++) { Assert.Equal(addressBook.People[i].Phones[j].Type, roundTripped.People[i].Phones[j].Type); Assert.Equal(addressBook.People[i].Phones[j].Number, roundTripped.People[i].Phones[j].Number); } } Assert.False(channel.Finish()); }
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 IByteBuffer ToByteBuffer() { CompositeByteBuffer compositeBuffer = Unpooled.CompositeBuffer(this.value.Count); compositeBuffer.AddComponents(this.value); compositeBuffer.SetWriterIndex(this.size); compositeBuffer.SetReaderIndex(0); return(compositeBuffer); }
public void TestCompositeBufferDecoder() { string s = "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5emFiY2Rl"; IByteBuffer src1 = Unpooled.CopiedBuffer(Encoding.ASCII.GetBytes(s.Substring(0, 10))); IByteBuffer src2 = Unpooled.CopiedBuffer(Encoding.ASCII.GetBytes(s.Substring(10))); var src = new CompositeByteBuffer(src1.Allocator, 2, src1, src2); IByteBuffer expectedDecoded = Unpooled.CopiedBuffer(Encoding.ASCII.GetBytes("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcde")); TestDecode(src, expectedDecoded); }
static IByteBuffer NewCompositeBuffer(IByteBufferAllocator alloc) { CompositeByteBuffer compositeByteBuf = alloc.CompositeBuffer(); compositeByteBuf.AddComponent(true, alloc.DirectBuffer(4).WriteInt(100)); compositeByteBuf.AddComponent(true, alloc.DirectBuffer(8).WriteLong(123)); compositeByteBuf.AddComponent(true, alloc.DirectBuffer(8).WriteLong(456)); Assert.Equal(ExpectedBytes, compositeByteBuf.ReadableBytes); return(compositeByteBuf); }
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 override void AddFrame(IByteBuffer data) { if (!(Element.Buffer is CompositeByteBuffer)) { throw new DicomImagingException("Expected pixel data element to have a CompositeByteBuffer"); } CompositeByteBuffer buffer = Element.Buffer as CompositeByteBuffer; buffer.Buffers.Add(data); NumberOfFrames++; }
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 Run(Person.Types.PhoneType phoneType, string number, bool isCompositeBuffer) { var phoneNumber = new Person.Types.PhoneNumber { Type = phoneType, Number = number }; var channel = new EmbeddedChannel( new ProtobufVarint32FrameDecoder(), new ProtobufDecoder(Person.Types.PhoneNumber.Parser), new ProtobufVarint32LengthFieldPrepender(), new ProtobufEncoder()); Assert.True(channel.WriteOutbound(phoneNumber)); var buffer = channel.ReadOutbound <IByteBuffer>(); Assert.NotNull(buffer); Assert.True(buffer.ReadableBytes > 0); var data = new byte[buffer.ReadableBytes]; buffer.ReadBytes(data); IByteBuffer inputBuffer; if (isCompositeBuffer) { inputBuffer = new CompositeByteBuffer(UnpooledByteBufferAllocator.Default, 2, Unpooled.CopiedBuffer(data, 0, 2), Unpooled.CopiedBuffer(data, 2, data.Length - 2)); } else { inputBuffer = Unpooled.WrappedBuffer(data); } Assert.True(channel.WriteInbound(inputBuffer)); var message = channel.ReadInbound <IMessage>(); Assert.NotNull(message); Assert.IsType <Person.Types.PhoneNumber>(message); var roundTripped = (Person.Types.PhoneNumber)message; Assert.Equal(phoneNumber.Type, roundTripped.Type); Assert.Equal(phoneNumber.Number, roundTripped.Number); Assert.False(channel.Finish()); }
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 CompositeHeapBufferWithCapacity() { IByteBufferAllocator allocator = this.NewAllocator(); CompositeByteBuffer buffer = allocator.CompositeHeapBuffer(8); try { this.AssertCompositeByteBuffer(buffer, 8); } 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(); }
protected override void Dispose(bool disposing) { base.Dispose(disposing); if (disposing) { TaskCompletionSource <int> p = _readCompletionSource; if (p is object) { _readCompletionSource = null; _ = p.TrySetResult(0); } _ownedInputBuffer.SafeRelease(); _ownedInputBuffer = null; } }
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 GetByteRange_WhenBufferIsSmallerThanRequestedCount_Throws() { // Arrange var bytes1 = Enumerable.Repeat((byte)1, 10).ToArray(); var bytes2 = Enumerable.Repeat((byte)2, 10).ToArray(); var bytes3 = Enumerable.Repeat((byte)3, 10).ToArray(); var memoryByteBuffer1 = new MemoryByteBuffer(bytes1); var memoryByteBuffer2 = new MemoryByteBuffer(bytes2); var memoryByteBuffer3 = new MemoryByteBuffer(bytes3); var compositeByteBuffer = new CompositeByteBuffer(memoryByteBuffer1, memoryByteBuffer2, memoryByteBuffer3); // Act + Assert var actual = new byte[10]; Assert.Throws <ArgumentException>(() => compositeByteBuffer.GetByteRange(0, 20, actual)); }
public static ReadableBuffer Composite(IEnumerable <ReadableBuffer> buffers) { Contract.Requires(buffers != null); CompositeByteBuffer composite = Unpooled.CompositeBuffer(); foreach (ReadableBuffer buf in buffers) { IByteBuffer byteBuffer = buf.buffer; if (byteBuffer.ReadableBytes > 0) { composite.AddComponent(byteBuffer); } } return(new ReadableBuffer(composite)); }
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 override void AddFrame(IByteBuffer data) { if (!(Element.Buffer is CompositeByteBuffer)) { throw new DicomImagingException("Expected pixel data element to have a CompositeByteBuffer."); } CompositeByteBuffer buffer = Element.Buffer as CompositeByteBuffer; if (BytesAllocated == 1) { data = new SwapByteBuffer(data, 2); } buffer.Buffers.Add(data); NumberOfFrames++; }
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()); }