public void TestNeverSkip()
{
IWebSocketExtensionFilter neverSkip = NeverSkipWebSocketExtensionFilter.Instance;
BinaryWebSocketFrame binaryFrame = new BinaryWebSocketFrame();
Assert.False(neverSkip.MustSkip(binaryFrame));
Assert.True(binaryFrame.Release());
TextWebSocketFrame textFrame = new TextWebSocketFrame();
Assert.False(neverSkip.MustSkip(textFrame));
Assert.True(textFrame.Release());
PingWebSocketFrame pingFrame = new PingWebSocketFrame();
Assert.False(neverSkip.MustSkip(pingFrame));
Assert.True(pingFrame.Release());
PongWebSocketFrame pongFrame = new PongWebSocketFrame();
Assert.False(neverSkip.MustSkip(pongFrame));
Assert.True(pongFrame.Release());
CloseWebSocketFrame closeFrame = new CloseWebSocketFrame();
Assert.False(neverSkip.MustSkip(closeFrame));
Assert.True(closeFrame.Release());
ContinuationWebSocketFrame continuationFrame = new ContinuationWebSocketFrame();
Assert.False(neverSkip.MustSkip(continuationFrame));
Assert.True(continuationFrame.Release());
}
public void NormalFrame()
{
var decoderChannel = new EmbeddedChannel(new PerFrameDeflateDecoder(false));
// initialize
var payload = new byte[300];
_random.NextBytes(payload);
var frame = new BinaryWebSocketFrame(true,
WebSocketRsv.Rsv3, Unpooled.WrappedBuffer(payload));
// execute
Assert.True(decoderChannel.WriteInbound(frame));
var newFrame = decoderChannel.ReadInbound <BinaryWebSocketFrame>();
// test
Assert.NotNull(newFrame);
Assert.NotNull(newFrame.Content);
Assert.Equal(WebSocketRsv.Rsv3, newFrame.Rsv);
Assert.Equal(300, newFrame.Content.ReadableBytes);
var finalPayload = new byte[300];
newFrame.Content.ReadBytes(finalPayload);
Assert.Equal(payload, finalPayload);
newFrame.Release();
}
public void AlreadyCompressedFrame()
{
var encoderChannel = new EmbeddedChannel(new PerFrameDeflateEncoder(9, 15, false));
var payload = new byte[300];
this.random.NextBytes(payload);
var frame = new BinaryWebSocketFrame(true,
WebSocketRsv.Rsv3 | WebSocketRsv.Rsv1, Unpooled.WrappedBuffer(payload));
encoderChannel.WriteOutbound(frame);
var newFrame = encoderChannel.ReadOutbound <BinaryWebSocketFrame>();
Assert.NotNull(newFrame);
Assert.NotNull(newFrame.Content);
Assert.IsType <BinaryWebSocketFrame>(newFrame);
Assert.Equal(WebSocketRsv.Rsv3 | WebSocketRsv.Rsv1, newFrame.Rsv);
Assert.Equal(300, newFrame.Content.ReadableBytes);
var finalPayload = new byte[300];
newFrame.Content.ReadBytes(finalPayload);
Assert.Equal(payload, finalPayload);
newFrame.Release();
}
protected override void Decode(IChannelHandlerContext ctx, WebSocketFrame msg, List <object> output)
{
var decompressedContent = DecompressContent(ctx, msg);
WebSocketFrame outMsg = null;
switch (msg.Opcode)
{
case Opcode.Text:
outMsg = new TextWebSocketFrame(msg.IsFinalFragment, NewRsv(msg), decompressedContent);
break;
case Opcode.Binary:
outMsg = new BinaryWebSocketFrame(msg.IsFinalFragment, NewRsv(msg), decompressedContent);
break;
case Opcode.Cont:
outMsg = new ContinuationWebSocketFrame(msg.IsFinalFragment, NewRsv(msg), decompressedContent);
break;
default:
ThrowHelper.ThrowCodecException_UnexpectedFrameType(msg);
break;
}
output.Add(outMsg);
}
protected override void Encode(IChannelHandlerContext context, IMessage message, List <object> output)
{
Contract.Requires(context != null);
Contract.Requires(message != null);
Contract.Requires(output != null);
IByteBuffer buffer = null;
try
{
int size = message.CalculateSize();
if (size == 0)
{
return;
}
buffer = Unpooled.WrappedBuffer(message.ToByteArray());
var frame = new BinaryWebSocketFrame(buffer);
output.Add(frame);
buffer = null;
frame = null;
}
catch (Exception exception)
{
throw new CodecException(exception);
}
finally
{
buffer?.Release();
}
}
public void CompressedFrame()
{
var encoderChannel = new EmbeddedChannel(
ZlibCodecFactory.NewZlibEncoder(ZlibWrapper.None, 9, 15, 8));
var decoderChannel = new EmbeddedChannel(new PerFrameDeflateDecoder(false));
// initialize
var payload = new byte[300];
_random.NextBytes(payload);
Assert.True(encoderChannel.WriteOutbound(Unpooled.WrappedBuffer(payload)));
var compressedPayload = encoderChannel.ReadOutbound <IByteBuffer>();
var compressedFrame = new BinaryWebSocketFrame(true,
WebSocketRsv.Rsv1 | WebSocketRsv.Rsv3,
compressedPayload.Slice(0, compressedPayload.ReadableBytes - 4));
// execute
Assert.True(decoderChannel.WriteInbound(compressedFrame));
var uncompressedFrame = decoderChannel.ReadInbound <BinaryWebSocketFrame>();
// test
Assert.NotNull(uncompressedFrame);
Assert.NotNull(uncompressedFrame.Content);
Assert.Equal(WebSocketRsv.Rsv3, uncompressedFrame.Rsv);
Assert.Equal(300, uncompressedFrame.Content.ReadableBytes);
var finalPayload = new byte[300];
uncompressedFrame.Content.ReadBytes(finalPayload);
Assert.Equal(payload, finalPayload);
uncompressedFrame.Release();
}
public void DecompressionSkip()
{
EmbeddedChannel encoderChannel = new EmbeddedChannel(
ZlibCodecFactory.NewZlibEncoder(ZlibWrapper.None, 9, 15, 8));
EmbeddedChannel decoderChannel = new EmbeddedChannel(new PerFrameDeflateDecoder(false, AlwaysSkipWebSocketExtensionFilter.Instance));
byte[] payload = new byte[300];
_random.NextBytes(payload);
Assert.True(encoderChannel.WriteOutbound(Unpooled.WrappedBuffer(payload)));
var compressedPayload = encoderChannel.ReadOutbound <IByteBuffer>();
BinaryWebSocketFrame compressedBinaryFrame = new BinaryWebSocketFrame(
true, WebSocketRsv.Rsv1 | WebSocketRsv.Rsv3, compressedPayload);
Assert.True(decoderChannel.WriteInbound(compressedBinaryFrame));
var inboundBinaryFrame = decoderChannel.ReadInbound <BinaryWebSocketFrame>();
Assert.NotNull(inboundBinaryFrame);
Assert.NotNull(inboundBinaryFrame.Content);
Assert.Equal(compressedPayload, inboundBinaryFrame.Content);
Assert.Equal(5, inboundBinaryFrame.Rsv);
Assert.True(inboundBinaryFrame.Release());
Assert.True(encoderChannel.FinishAndReleaseAll());
Assert.False(decoderChannel.Finish());
}
private void HandleBinaryWebSocketFrame(BinaryWebSocketFrame binaryWebSocketFrame, AppSession appSession)
{
var byteBuffer = binaryWebSocketFrame.Content;
var readBytes = new byte[byteBuffer.ReadableBytes];
byteBuffer.ReadBytes(readBytes);
var message = _packetCodec.Decode(readBytes);
var requestContext = new RequestContext()
{
AppSession = appSession, Request = message
};
var commandDescriptor = _commandContainer.Get(message.Command);
if (commandDescriptor != null)
{
var commandContext = new CommandContext(commandDescriptor, _serviceProvider);
if (!(_commandActivator.Create(commandContext) is ICommand command))
{
throw new NotImplementedException();
}
command.Execute(requestContext);
}
else
{
_logger.LogWarning($"The msg' command {byteBuffer} was not found.");
}
}
public void CompressedFrame()
{
var encoderChannel = new EmbeddedChannel(new PerFrameDeflateEncoder(9, 15, false));
var decoderChannel = new EmbeddedChannel(
ZlibCodecFactory.NewZlibDecoder(ZlibWrapper.None));
var payload = new byte[300];
this.random.NextBytes(payload);
var frame = new BinaryWebSocketFrame(true,
WebSocketRsv.Rsv3, Unpooled.WrappedBuffer(payload));
encoderChannel.WriteOutbound(frame);
var compressedFrame = encoderChannel.ReadOutbound <BinaryWebSocketFrame>();
Assert.NotNull(compressedFrame);
Assert.NotNull(compressedFrame.Content);
Assert.IsType <BinaryWebSocketFrame>(compressedFrame);
Assert.Equal(WebSocketRsv.Rsv1 | WebSocketRsv.Rsv3, compressedFrame.Rsv);
decoderChannel.WriteInbound(compressedFrame.Content);
decoderChannel.WriteInbound(DeflateDecoder.FrameTail);
var uncompressedPayload = decoderChannel.ReadInbound <IByteBuffer>();
Assert.Equal(300, uncompressedPayload.ReadableBytes);
var finalPayload = new byte[300];
uncompressedPayload.ReadBytes(finalPayload);
Assert.Equal(payload, finalPayload);
uncompressedPayload.Release();
}
public async Task SendCommandByBytesAsync(ICommand command)
{
WebSocketFrame frame = new BinaryWebSocketFrame();
frame.Content.SetBytes(0, command.ToBytes());
await SendMessageAsync(frame);
_clientHandler.OnSendMessage(command.ToJson());
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="channel"></param>
/// <param name="data"></param>
/// <returns></returns>
public static async Task SendDataAsync(this IChannel channel, byte[] data)
{
if (channel != null && channel.Open)
{
IByteBuffer buffer = Unpooled.WrappedBuffer(data);
var socketFrame = new BinaryWebSocketFrame(buffer);
await channel.WriteAndFlushAsync(socketFrame);
}
}
public static async Task BroadCast(IByteBuffer message)
{
if (ChannelGroup == null)
{
return;
}
BinaryWebSocketFrame frame = new BinaryWebSocketFrame(message);
message.Retain();
await ChannelGroup.WriteAndFlushAsync(frame);
}
public void FragmentedFrame()
{
var encoderChannel = new EmbeddedChannel(
ZlibCodecFactory.NewZlibEncoder(ZlibWrapper.None, 9, 15, 8));
var decoderChannel = new EmbeddedChannel(new PerMessageDeflateDecoder(false));
// initialize
var payload = new byte[300];
_random.NextBytes(payload);
Assert.True(encoderChannel.WriteOutbound(Unpooled.WrappedBuffer(payload)));
var compressedPayload = encoderChannel.ReadOutbound <IByteBuffer>();
compressedPayload = compressedPayload.Slice(0, compressedPayload.ReadableBytes - 4);
int oneThird = compressedPayload.ReadableBytes / 3;
var compressedFrame1 = new BinaryWebSocketFrame(false,
WebSocketRsv.Rsv1 | WebSocketRsv.Rsv3,
compressedPayload.Slice(0, oneThird));
var compressedFrame2 = new ContinuationWebSocketFrame(false,
WebSocketRsv.Rsv3, compressedPayload.Slice(oneThird, oneThird));
var compressedFrame3 = new ContinuationWebSocketFrame(true,
WebSocketRsv.Rsv3, compressedPayload.Slice(oneThird * 2,
compressedPayload.ReadableBytes - oneThird * 2));
// execute
Assert.True(decoderChannel.WriteInbound(compressedFrame1.Retain()));
Assert.True(decoderChannel.WriteInbound(compressedFrame2.Retain()));
Assert.True(decoderChannel.WriteInbound(compressedFrame3));
var uncompressedFrame1 = decoderChannel.ReadInbound <BinaryWebSocketFrame>();
var uncompressedFrame2 = decoderChannel.ReadInbound <ContinuationWebSocketFrame>();
var uncompressedFrame3 = decoderChannel.ReadInbound <ContinuationWebSocketFrame>();
// test
Assert.NotNull(uncompressedFrame1);
Assert.NotNull(uncompressedFrame2);
Assert.NotNull(uncompressedFrame3);
Assert.Equal(WebSocketRsv.Rsv3, uncompressedFrame1.Rsv);
Assert.Equal(WebSocketRsv.Rsv3, uncompressedFrame2.Rsv);
Assert.Equal(WebSocketRsv.Rsv3, uncompressedFrame3.Rsv);
IByteBuffer finalPayloadWrapped = Unpooled.WrappedBuffer(uncompressedFrame1.Content,
uncompressedFrame2.Content, uncompressedFrame3.Content);
Assert.Equal(300, finalPayloadWrapped.ReadableBytes);
var finalPayload = new byte[300];
finalPayloadWrapped.ReadBytes(finalPayload);
Assert.Equal(payload, finalPayload);
finalPayloadWrapped.Release();
}
public void IllegalStateWhenDecompressionInProgress()
{
var selectivityDecompressionFilter = new SelectivityDecompressionFilter1();
EmbeddedChannel encoderChannel = new EmbeddedChannel(
ZlibCodecFactory.NewZlibEncoder(ZlibWrapper.None, 9, 15, 8));
EmbeddedChannel decoderChannel = new EmbeddedChannel(
new PerMessageDeflateDecoder(false, selectivityDecompressionFilter));
byte[] firstPayload = new byte[200];
_random.NextBytes(firstPayload);
byte[] finalPayload = new byte[50];
_random.NextBytes(finalPayload);
Assert.True(encoderChannel.WriteOutbound(Unpooled.WrappedBuffer(firstPayload)));
Assert.True(encoderChannel.WriteOutbound(Unpooled.WrappedBuffer(finalPayload)));
var compressedFirstPayload = encoderChannel.ReadOutbound <IByteBuffer>();
var compressedFinalPayload = encoderChannel.ReadOutbound <IByteBuffer>();
Assert.True(encoderChannel.FinishAndReleaseAll());
BinaryWebSocketFrame firstPart = new BinaryWebSocketFrame(false, WebSocketRsv.Rsv1, compressedFirstPayload);
ContinuationWebSocketFrame finalPart = new ContinuationWebSocketFrame(true, WebSocketRsv.Rsv1, compressedFinalPayload);
Assert.True(decoderChannel.WriteInbound(firstPart));
var outboundFirstPart = decoderChannel.ReadInbound <BinaryWebSocketFrame>();
//first part is decompressed
Assert.Equal(0, outboundFirstPart.Rsv);
Assert.Equal(firstPayload, ByteBufferUtil.GetBytes(outboundFirstPart.Content));
Assert.True(outboundFirstPart.Release());
//final part throwing exception
try
{
decoderChannel.WriteInbound(finalPart);
Assert.False(true);
}
catch (Exception exc)
{
Assert.IsType <DecoderException>(exc);
}
finally
{
Assert.True(finalPart.Release());
Assert.False(encoderChannel.FinishAndReleaseAll());
}
}
public void CompressionSkipForBinaryFrame()
{
EmbeddedChannel encoderChannel = new EmbeddedChannel(new PerMessageDeflateEncoder(9, 15, false, AlwaysSkipWebSocketExtensionFilter.Instance));
byte[] payload = new byte[300];
_random.NextBytes(payload);
WebSocketFrame binaryFrame = new BinaryWebSocketFrame(Unpooled.WrappedBuffer(payload));
Assert.True(encoderChannel.WriteOutbound(binaryFrame.Copy()));
var outboundFrame = encoderChannel.ReadOutbound <WebSocketFrame>();
Assert.Equal(0, outboundFrame.Rsv);
Assert.Equal(payload, ByteBufferUtil.GetBytes(outboundFrame.Content));
Assert.True(outboundFrame.Release());
Assert.False(encoderChannel.Finish());
}
public void MultiCompressedPayloadWithinFrame()
{
var encoderChannel = new EmbeddedChannel(
ZlibCodecFactory.NewZlibEncoder(ZlibWrapper.None, 9, 15, 8));
var decoderChannel = new EmbeddedChannel(new PerMessageDeflateDecoder(false));
var payload1 = new byte[100];
this.random.NextBytes(payload1);
var payload2 = new byte[100];
this.random.NextBytes(payload2);
encoderChannel.WriteOutbound(Unpooled.WrappedBuffer(payload1));
var compressedPayload1 = encoderChannel.ReadOutbound <IByteBuffer>();
encoderChannel.WriteOutbound(Unpooled.WrappedBuffer(payload2));
var compressedPayload2 = encoderChannel.ReadOutbound <IByteBuffer>();
var compressedFrame = new BinaryWebSocketFrame(true,
WebSocketRsv.Rsv1 | WebSocketRsv.Rsv3,
Unpooled.WrappedBuffer(
compressedPayload1,
compressedPayload2.Slice(0, compressedPayload2.ReadableBytes - 4)));
decoderChannel.WriteInbound(compressedFrame);
var uncompressedFrame = decoderChannel.ReadInbound <BinaryWebSocketFrame>();
Assert.NotNull(uncompressedFrame);
Assert.NotNull(uncompressedFrame.Content);
Assert.IsType <BinaryWebSocketFrame>(uncompressedFrame);
Assert.Equal(WebSocketRsv.Rsv3, uncompressedFrame.Rsv);
Assert.Equal(200, uncompressedFrame.Content.ReadableBytes);
var finalPayload1 = new byte[100];
uncompressedFrame.Content.ReadBytes(finalPayload1);
Assert.Equal(payload1, finalPayload1);
var finalPayload2 = new byte[100];
uncompressedFrame.Content.ReadBytes(finalPayload2);
Assert.Equal(payload2, finalPayload2);
uncompressedFrame.Release();
}
public void IllegalStateWhenCompressionInProgress()
{
var selectivityCompressionFilter = new SelectivityDecompressionFilter1();
EmbeddedChannel encoderChannel = new EmbeddedChannel(
new PerMessageDeflateEncoder(9, 15, false, selectivityCompressionFilter));
byte[] firstPayload = new byte[200];
_random.NextBytes(firstPayload);
byte[] finalPayload = new byte[90];
_random.NextBytes(finalPayload);
BinaryWebSocketFrame firstPart = new BinaryWebSocketFrame(false, 0, Unpooled.WrappedBuffer(firstPayload));
ContinuationWebSocketFrame finalPart = new ContinuationWebSocketFrame(true, 0, Unpooled.WrappedBuffer(finalPayload));
Assert.True(encoderChannel.WriteOutbound(firstPart));
var outboundFirstPart = encoderChannel.ReadOutbound <BinaryWebSocketFrame>();
//first part is compressed
Assert.Equal(WebSocketRsv.Rsv1, outboundFirstPart.Rsv);
Assert.NotEqual(firstPayload, ByteBufferUtil.GetBytes(outboundFirstPart.Content));
Assert.True(outboundFirstPart.Release());
//final part throwing exception
try
{
encoderChannel.WriteOutbound(finalPart);
Assert.False(true);
}
catch (Exception exc)
{
var ae = exc as AggregateException;
Assert.NotNull(ae);
Assert.IsType <EncoderException>(ae.InnerException);
}
finally
{
Assert.True(finalPart.Release());
Assert.False(encoderChannel.FinishAndReleaseAll());
}
}
public void SelectivityCompressionSkip()
{
var selectivityCompressionFilter = new SelectivityDecompressionFilter0();
EmbeddedChannel encoderChannel = new EmbeddedChannel(
new PerMessageDeflateEncoder(9, 15, false, selectivityCompressionFilter));
EmbeddedChannel decoderChannel = new EmbeddedChannel(
ZlibCodecFactory.NewZlibDecoder(ZlibWrapper.None));
string textPayload = "not compressed payload";
byte[] binaryPayload = new byte[101];
_random.NextBytes(binaryPayload);
WebSocketFrame textFrame = new TextWebSocketFrame(textPayload);
BinaryWebSocketFrame binaryFrame = new BinaryWebSocketFrame(Unpooled.WrappedBuffer(binaryPayload));
Assert.True(encoderChannel.WriteOutbound(textFrame));
Assert.True(encoderChannel.WriteOutbound(binaryFrame));
var outboundTextFrame = encoderChannel.ReadOutbound <WebSocketFrame>();
//compression skipped for textFrame
Assert.Equal(0, outboundTextFrame.Rsv);
Assert.Equal(textPayload, outboundTextFrame.Content.ToString(Encoding.UTF8));
Assert.True(outboundTextFrame.Release());
var outboundBinaryFrame = encoderChannel.ReadOutbound <WebSocketFrame>();
//compression not skipped for binaryFrame
Assert.Equal(WebSocketRsv.Rsv1, outboundBinaryFrame.Rsv);
Assert.True(decoderChannel.WriteInbound(outboundBinaryFrame.Content.Retain()));
var uncompressedBinaryPayload = decoderChannel.ReadInbound <IByteBuffer>();
Assert.Equal(binaryPayload, ByteBufferUtil.GetBytes(uncompressedBinaryPayload));
Assert.True(outboundBinaryFrame.Release());
Assert.True(uncompressedBinaryPayload.Release());
Assert.False(encoderChannel.Finish());
Assert.False(decoderChannel.Finish());
}
protected override void Encode(IChannelHandlerContext ctx, WebSocketFrame msg, List <object> output)
{
IByteBuffer compressedContent = null;
if (msg.Content.IsReadable())
{
compressedContent = CompressContent(ctx, msg);
}
else if (msg.IsFinalFragment)
{
// Set empty DEFLATE block manually for unknown buffer size
// https://tools.ietf.org/html/rfc7692#section-7.2.3.6
compressedContent = DeflateDecoder.EmptyDeflateBlock.Duplicate();
}
else
{
ThrowHelper.ThrowCodecException_CannotCompressContentBuffer();
}
WebSocketFrame outMsg = null;
switch (msg.Opcode)
{
case Opcode.Text:
outMsg = new TextWebSocketFrame(msg.IsFinalFragment, Rsv(msg), compressedContent);
break;
case Opcode.Binary:
outMsg = new BinaryWebSocketFrame(msg.IsFinalFragment, Rsv(msg), compressedContent);
break;
case Opcode.Cont:
outMsg = new ContinuationWebSocketFrame(msg.IsFinalFragment, Rsv(msg), compressedContent);
break;
default:
ThrowHelper.ThrowCodecException_UnexpectedFrameType(msg);
break;
}
output.Add(outMsg);
}
public void CompressedEmptyFrame()
{
var encoderChannel = new EmbeddedChannel(
ZlibCodecFactory.NewZlibEncoder(ZlibWrapper.None, 9, 15, 8));
var decoderChannel = new EmbeddedChannel(new PerFrameDeflateDecoder(false));
encoderChannel.WriteOutbound(Unpooled.Empty);
var compressedPayload = encoderChannel.ReadOutbound <IByteBuffer>();
var compressedFrame =
new BinaryWebSocketFrame(true, WebSocketRsv.Rsv1 | WebSocketRsv.Rsv3, compressedPayload);
decoderChannel.WriteInbound(compressedFrame);
var uncompressedFrame = decoderChannel.ReadInbound <BinaryWebSocketFrame>();
Assert.NotNull(uncompressedFrame);
Assert.NotNull(uncompressedFrame.Content);
Assert.IsType <BinaryWebSocketFrame>(uncompressedFrame);
Assert.Equal(WebSocketRsv.Rsv3, uncompressedFrame.Rsv);
Assert.Equal(0, uncompressedFrame.Content.ReadableBytes);
uncompressedFrame.Release();
}
public void SelectivityDecompressionSkip()
{
var selectivityDecompressionFilter = new SelectivityDecompressionFilter0();
EmbeddedChannel encoderChannel = new EmbeddedChannel(
ZlibCodecFactory.NewZlibEncoder(ZlibWrapper.None, 9, 15, 8));
EmbeddedChannel decoderChannel = new EmbeddedChannel(
new PerMessageDeflateDecoder(false, selectivityDecompressionFilter));
string textPayload = "compressed payload";
byte[] binaryPayload = new byte[300];
_random.NextBytes(binaryPayload);
Assert.True(encoderChannel.WriteOutbound(Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(textPayload))));
Assert.True(encoderChannel.WriteOutbound(Unpooled.WrappedBuffer(binaryPayload)));
var compressedTextPayload = encoderChannel.ReadOutbound <IByteBuffer>();
var compressedBinaryPayload = encoderChannel.ReadOutbound <IByteBuffer>();
TextWebSocketFrame compressedTextFrame = new TextWebSocketFrame(true, WebSocketRsv.Rsv1, compressedTextPayload);
BinaryWebSocketFrame compressedBinaryFrame = new BinaryWebSocketFrame(true, WebSocketRsv.Rsv1, compressedBinaryPayload);
Assert.True(decoderChannel.WriteInbound(compressedTextFrame));
Assert.True(decoderChannel.WriteInbound(compressedBinaryFrame));
var inboundTextFrame = decoderChannel.ReadInbound <TextWebSocketFrame>();
var inboundBinaryFrame = decoderChannel.ReadInbound <BinaryWebSocketFrame>();
Assert.Equal(WebSocketRsv.Rsv1, inboundTextFrame.Rsv);
Assert.Equal(compressedTextPayload, inboundTextFrame.Content);
Assert.True(inboundTextFrame.Release());
Assert.Equal(0, inboundBinaryFrame.Rsv);
Assert.Equal(binaryPayload, ByteBufferUtil.GetBytes(inboundBinaryFrame.Content));
Assert.True(inboundBinaryFrame.Release());
Assert.True(encoderChannel.FinishAndReleaseAll());
Assert.False(decoderChannel.Finish());
}
protected override void Decode(IChannelHandlerContext ctx, IByteBuffer msg, List <Object> output)
{
WebSocketFrame webSocketFrame = new BinaryWebSocketFrame(msg);
output.Add(webSocketFrame);
}
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);
}
public async Task SendBinaryAsync(byte[] bytes)
{
var frame = new BinaryWebSocketFrame(Unpooled.WrappedBuffer(bytes));
await _channel.WriteAndFlushAsync(frame);
}
public void FragmentedFrame()
{
var encoderChannel = new EmbeddedChannel(new PerMessageDeflateEncoder(9, 15, false, NeverSkipWebSocketExtensionFilter.Instance));
var decoderChannel = new EmbeddedChannel(
ZlibCodecFactory.NewZlibDecoder(ZlibWrapper.None));
// initialize
var payload1 = new byte[100];
_random.NextBytes(payload1);
var payload2 = new byte[100];
_random.NextBytes(payload2);
var payload3 = new byte[100];
_random.NextBytes(payload3);
var frame1 = new BinaryWebSocketFrame(false,
WebSocketRsv.Rsv3, Unpooled.WrappedBuffer(payload1));
var frame2 = new ContinuationWebSocketFrame(false,
WebSocketRsv.Rsv3, Unpooled.WrappedBuffer(payload2));
var frame3 = new ContinuationWebSocketFrame(true,
WebSocketRsv.Rsv3, Unpooled.WrappedBuffer(payload3));
// execute
Assert.True(encoderChannel.WriteOutbound(frame1));
Assert.True(encoderChannel.WriteOutbound(frame2));
Assert.True(encoderChannel.WriteOutbound(frame3));
var compressedFrame1 = encoderChannel.ReadOutbound <BinaryWebSocketFrame>();
var compressedFrame2 = encoderChannel.ReadOutbound <ContinuationWebSocketFrame>();
var compressedFrame3 = encoderChannel.ReadOutbound <ContinuationWebSocketFrame>();
// test
Assert.NotNull(compressedFrame1);
Assert.NotNull(compressedFrame2);
Assert.NotNull(compressedFrame3);
Assert.Equal(WebSocketRsv.Rsv1 | WebSocketRsv.Rsv3, compressedFrame1.Rsv);
Assert.Equal(WebSocketRsv.Rsv3, compressedFrame2.Rsv);
Assert.Equal(WebSocketRsv.Rsv3, compressedFrame3.Rsv);
Assert.False(compressedFrame1.IsFinalFragment);
Assert.False(compressedFrame2.IsFinalFragment);
Assert.True(compressedFrame3.IsFinalFragment);
Assert.True(decoderChannel.WriteInbound(compressedFrame1.Content));
var uncompressedPayload1 = decoderChannel.ReadInbound <IByteBuffer>();
var finalPayload1 = new byte[100];
uncompressedPayload1.ReadBytes(finalPayload1);
Assert.Equal(payload1, finalPayload1);
uncompressedPayload1.Release();
Assert.True(decoderChannel.WriteInbound(compressedFrame2.Content));
var uncompressedPayload2 = decoderChannel.ReadInbound <IByteBuffer>();
var finalPayload2 = new byte[100];
uncompressedPayload2.ReadBytes(finalPayload2);
Assert.Equal(payload2, finalPayload2);
uncompressedPayload2.Release();
Assert.True(decoderChannel.WriteInbound(compressedFrame3.Content));
Assert.True(decoderChannel.WriteInbound(DeflateDecoder.FrameTail.Duplicate()));
var uncompressedPayload3 = decoderChannel.ReadInbound <IByteBuffer>();
var finalPayload3 = new byte[100];
uncompressedPayload3.ReadBytes(finalPayload3);
Assert.Equal(payload3, finalPayload3);
uncompressedPayload3.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);
}
public void FramementedFrame()
{
var encoderChannel = new EmbeddedChannel(new PerFrameDeflateEncoder(9, 15, false));
var decoderChannel = new EmbeddedChannel(
ZlibCodecFactory.NewZlibDecoder(ZlibWrapper.None));
var payload1 = new byte[100];
this.random.NextBytes(payload1);
var payload2 = new byte[100];
this.random.NextBytes(payload2);
var payload3 = new byte[100];
this.random.NextBytes(payload3);
var frame1 = new BinaryWebSocketFrame(false,
WebSocketRsv.Rsv3, Unpooled.WrappedBuffer(payload1));
var frame2 = new ContinuationWebSocketFrame(false,
WebSocketRsv.Rsv3, Unpooled.WrappedBuffer(payload2));
var frame3 = new ContinuationWebSocketFrame(true,
WebSocketRsv.Rsv3, Unpooled.WrappedBuffer(payload3));
encoderChannel.WriteOutbound(frame1);
encoderChannel.WriteOutbound(frame2);
encoderChannel.WriteOutbound(frame3);
var compressedFrame1 = encoderChannel.ReadOutbound <BinaryWebSocketFrame>();
var compressedFrame2 = encoderChannel.ReadOutbound <ContinuationWebSocketFrame>();
var compressedFrame3 = encoderChannel.ReadOutbound <ContinuationWebSocketFrame>();
Assert.NotNull(compressedFrame1);
Assert.NotNull(compressedFrame2);
Assert.NotNull(compressedFrame3);
Assert.Equal(WebSocketRsv.Rsv1 | WebSocketRsv.Rsv3, compressedFrame1.Rsv);
Assert.Equal(WebSocketRsv.Rsv1 | WebSocketRsv.Rsv3, compressedFrame2.Rsv);
Assert.Equal(WebSocketRsv.Rsv1 | WebSocketRsv.Rsv3, compressedFrame3.Rsv);
Assert.False(compressedFrame1.IsFinalFragment);
Assert.False(compressedFrame2.IsFinalFragment);
Assert.True(compressedFrame3.IsFinalFragment);
decoderChannel.WriteInbound(compressedFrame1.Content);
decoderChannel.WriteInbound(Unpooled.WrappedBuffer(DeflateDecoder.FrameTail));
var uncompressedPayload1 = decoderChannel.ReadInbound <IByteBuffer>();
var finalPayload1 = new byte[100];
uncompressedPayload1.ReadBytes(finalPayload1);
Assert.Equal(payload1, finalPayload1);
uncompressedPayload1.Release();
decoderChannel.WriteInbound(compressedFrame2.Content);
decoderChannel.WriteInbound(Unpooled.WrappedBuffer(DeflateDecoder.FrameTail));
var uncompressedPayload2 = decoderChannel.ReadInbound <IByteBuffer>();
var finalPayload2 = new byte[100];
uncompressedPayload2.ReadBytes(finalPayload2);
Assert.Equal(payload2, finalPayload2);
uncompressedPayload2.Release();
decoderChannel.WriteInbound(compressedFrame3.Content);
decoderChannel.WriteInbound(Unpooled.WrappedBuffer(DeflateDecoder.FrameTail));
var uncompressedPayload3 = decoderChannel.ReadInbound <IByteBuffer>();
var finalPayload3 = new byte[100];
uncompressedPayload3.ReadBytes(finalPayload3);
Assert.Equal(payload3, finalPayload3);
uncompressedPayload3.Release();
}
