public void WrittenBuffersEquals()
{
//XXX Same tests than testEquals with written AggregateChannelBuffers
// Different length.
IByteBuffer a = Unpooled.WrappedBuffer(new byte[] { 1 });
IByteBuffer b = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[] { 1 }, new byte[1]));
IByteBuffer c = Unpooled.WrappedBuffer(new byte[] { 2 });
// to enable writeBytes
b.SetWriterIndex(b.WriterIndex - 1);
b.WriteBytes(c);
Assert.False(ByteBufferUtil.Equals(a, b));
a.Release();
b.Release();
c.Release();
// Same content, same firstIndex, short length.
a = Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 });
b = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[] { 1 }, new byte[2]));
c = Unpooled.WrappedBuffer(new byte[] { 2 });
// to enable writeBytes
b.SetWriterIndex(b.WriterIndex - 2);
b.WriteBytes(c);
c.Release();
c = Unpooled.WrappedBuffer(new byte[] { 3 });
b.WriteBytes(c);
Assert.True(ByteBufferUtil.Equals(a, b));
a.Release();
b.Release();
c.Release();
// Same content, different firstIndex, short length.
a = Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 });
b = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[] { 0, 1, 2, 3, 4 }, 1, 3));
c = Unpooled.WrappedBuffer(new byte[] { 0, 1, 2, 3, 4 }, 3, 1);
// to enable writeBytes
b.SetWriterIndex(b.WriterIndex - 1);
b.WriteBytes(c);
Assert.True(ByteBufferUtil.Equals(a, b));
a.Release();
b.Release();
c.Release();
// Different content, same firstIndex, short length.
a = Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 });
b = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[] { 1, 2 }, new byte[1]));
c = Unpooled.WrappedBuffer(new byte[] { 4 });
// to enable writeBytes
b.SetWriterIndex(b.WriterIndex - 1);
b.WriteBytes(c);
Assert.False(ByteBufferUtil.Equals(a, b));
a.Release();
b.Release();
c.Release();
// Different content, different firstIndex, short length.
a = Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 });
b = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[] { 0, 1, 2, 4, 5 }, 1, 3));
c = Unpooled.WrappedBuffer(new byte[] { 0, 1, 2, 4, 5 }, 3, 1);
// to enable writeBytes
b.SetWriterIndex(b.WriterIndex - 1);
b.WriteBytes(c);
Assert.False(ByteBufferUtil.Equals(a, b));
a.Release();
b.Release();
c.Release();
// Same content, same firstIndex, long length.
a = Unpooled.WrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
b = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 }, new byte[7]));
c = Unpooled.WrappedBuffer(new byte[] { 4, 5, 6 });
// to enable writeBytes
b.SetWriterIndex(b.WriterIndex - 7);
b.WriteBytes(c);
c.Release();
c = Unpooled.WrappedBuffer(new byte[] { 7, 8, 9, 10 });
b.WriteBytes(c);
Assert.True(ByteBufferUtil.Equals(a, b));
a.Release();
b.Release();
c.Release();
// Same content, different firstIndex, long length.
a = Unpooled.WrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
b = Unpooled.WrappedBuffer(
Unpooled.WrappedBuffer(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }, 1, 10));
c = Unpooled.WrappedBuffer(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }, 6, 5);
// to enable writeBytes
b.SetWriterIndex(b.WriterIndex - 5);
b.WriteBytes(c);
Assert.True(ByteBufferUtil.Equals(a, b));
a.Release();
b.Release();
c.Release();
// Different content, same firstIndex, long length.
a = Unpooled.WrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
b = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[] { 1, 2, 3, 4, 6 }, new byte[5]));
c = Unpooled.WrappedBuffer(new byte[] { 7, 8, 5, 9, 10 });
// to enable writeBytes
b.SetWriterIndex(b.WriterIndex - 5);
b.WriteBytes(c);
Assert.False(ByteBufferUtil.Equals(a, b));
a.Release();
b.Release();
c.Release();
// Different content, different firstIndex, long length.
a = Unpooled.WrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
b = Unpooled.WrappedBuffer(
Unpooled.WrappedBuffer(new byte[] { 0, 1, 2, 3, 4, 6, 7, 8, 5, 9, 10, 11 }, 1, 10));
c = Unpooled.WrappedBuffer(new byte[] { 0, 1, 2, 3, 4, 6, 7, 8, 5, 9, 10, 11 }, 6, 5);
// to enable writeBytes
b.SetWriterIndex(b.WriterIndex - 5);
b.WriteBytes(c);
Assert.False(ByteBufferUtil.Equals(a, b));
a.Release();
b.Release();
c.Release();
}
public override IByteBuffer EncodePayload()
{
return(Unpooled.WrappedBuffer(AudioData));
}
async Task RunMqttClientScenarioAsync(IChannel channel, ReadListeningHandler readListener)
{
await channel.WriteAndFlushAsync(new ConnectPacket
{
ClientId = ClientId,
Username = "******",
Password = "******",
WillTopicName = "last/word",
WillMessage = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes("oops"))
});
var connAckPacket = Assert.IsType <ConnAckPacket>(await readListener.ReceiveAsync());
Assert.Equal(ConnectReturnCode.Accepted, connAckPacket.ReturnCode);
int subscribePacketId = GetRandomPacketId();
int unsubscribePacketId = GetRandomPacketId();
await channel.WriteAndFlushManyAsync(
new SubscribePacket(subscribePacketId,
new SubscriptionRequest(SubscribeTopicFilter1, QualityOfService.ExactlyOnce),
new SubscriptionRequest(SubscribeTopicFilter2, QualityOfService.AtLeastOnce),
new SubscriptionRequest("for/unsubscribe", QualityOfService.AtMostOnce)),
new UnsubscribePacket(unsubscribePacketId, "for/unsubscribe"));
var subAckPacket = Assert.IsType <SubAckPacket>(await readListener.ReceiveAsync());
Assert.Equal(subscribePacketId, subAckPacket.PacketId);
Assert.Equal(3, subAckPacket.ReturnCodes.Count);
Assert.Equal(QualityOfService.ExactlyOnce, subAckPacket.ReturnCodes[0]);
Assert.Equal(QualityOfService.AtLeastOnce, subAckPacket.ReturnCodes[1]);
Assert.Equal(QualityOfService.AtMostOnce, subAckPacket.ReturnCodes[2]);
var unsubAckPacket = Assert.IsType <UnsubAckPacket>(await readListener.ReceiveAsync());
Assert.Equal(unsubscribePacketId, unsubAckPacket.PacketId);
int publishQoS1PacketId = GetRandomPacketId();
await channel.WriteAndFlushManyAsync(
new PublishPacket(QualityOfService.AtMostOnce, false, false)
{
TopicName = PublishC2STopic,
Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(PublishC2SQos0Payload))
},
new PublishPacket(QualityOfService.AtLeastOnce, false, false)
{
PacketId = publishQoS1PacketId,
TopicName = PublishC2SQos1Topic,
Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(PublishC2SQos1Payload))
});
//new PublishPacket(QualityOfService.AtLeastOnce, false, false) { TopicName = "feedback/qos/One", Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes("QoS 1 test. Different data length.")) });
var pubAckPacket = Assert.IsType <PubAckPacket>(await readListener.ReceiveAsync());
Assert.Equal(publishQoS1PacketId, pubAckPacket.PacketId);
var publishPacket = Assert.IsType <PublishPacket>(await readListener.ReceiveAsync());
Assert.Equal(QualityOfService.AtLeastOnce, publishPacket.QualityOfService);
Assert.Equal(PublishS2CQos1Topic, publishPacket.TopicName);
Assert.Equal(PublishS2CQos1Payload, publishPacket.Payload.ToString(Encoding.UTF8));
await channel.WriteAndFlushManyAsync(
PubAckPacket.InResponseTo(publishPacket),
DisconnectPacket.Instance);
}
public async Task SendAsync(byte[] bytes)
{
await clientChannel?.WriteAndFlushAsync(Unpooled.WrappedBuffer(bytes));
}
protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List <object> output)
{
Debug.Assert(context != null);
Debug.Assert(input != null);
Debug.Assert(output != null);
while (true)
{
input.MarkReaderIndex();
var firstByteInPacketIndex = input.ReaderIndex;
if (input.ReadableBytes < 2)
{
break;
}
var payloadLengthIncludingOpcode = (int)input.ReadByte();
var isTwoByteLen = false;
if (payloadLengthIncludingOpcode >= 160)
{
payloadLengthIncludingOpcode = (payloadLengthIncludingOpcode - 160) * 256 + input.ReadByte();
isTwoByteLen = true;
}
var inboundDataReadyForProcessing = input.ReadableBytes >= payloadLengthIncludingOpcode;
if (!inboundDataReadyForProcessing)
{
input.ResetReaderIndex();
break;
}
if (payloadLengthIncludingOpcode == 1)
{
// Read a 1-byte slice, which is the opcode.
var opcode = input.ReadByte();
var newPacket = Unpooled.Buffer(1);
newPacket.WriteByte(opcode);
// Update the reader index to 1, which means that there are zero
// readable bytes in the slice.
newPacket.SetReaderIndex(1);
newPacket.MarkReaderIndex();
Debug.Assert(newPacket.ReadableBytes == 0);
output.Add(newPacket);
}
else if (!isTwoByteLen)
{
var remainingBytes = payloadLengthIncludingOpcode;
var lastPayloadByte = input.ReadByte();
var opcode = input.ReadByte();
remainingBytes -= 2;
var payload = new byte[payloadLengthIncludingOpcode];
payload[0] = opcode;
input.ReadBytes(payload, 1, remainingBytes);
payload[payload.Length - 1] = lastPayloadByte;
var newPacket = Unpooled.WrappedBuffer(payload);
newPacket.SetReaderIndex(1);
newPacket.MarkReaderIndex();
output.Add(newPacket);
}
else
{
var remainingBytes = payloadLengthIncludingOpcode;
var opcode = input.ReadByte();
remainingBytes--;
var payload = new byte[payloadLengthIncludingOpcode];
payload[0] = opcode;
input.ReadBytes(payload, 1, remainingBytes);
var newPacket = Unpooled.WrappedBuffer(payload);
newPacket.SetReaderIndex(1);
newPacket.MarkReaderIndex();
output.Add(newPacket);
}
}
}
public static Func <ClientCommand, ITcpRequest> CmdSend(Func <ClientCommand, string> transform)
=>
command =>
new ClientDataSend(
command.Client.Id,
Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(transform(command) + "\n")));
public override void ExceptionCaught(IChannelHandlerContext context, Exception exception)
{
WriteResponse(context, Unpooled.WrappedBuffer(JT809SuperiorWebAPIHandler.ErrorHttpResponse(exception).Data), TypeJson, JT809SuperiorWebAPIHandler.ErrorHttpResponse(exception).Data.Length);
logger.LogError(exception, exception.Message);
context.CloseAsync();
}
/**
* The {@link OneByteToThreeStringsDecoder} decodes this {@code byte[]} into three messages.
*/
static IByteBuffer NewOneMessage() => Unpooled.WrappedBuffer(new byte[] { 1 });
IEnumerable <TestScenarioStep> GetMqttClientScenario(Func <object> currentMessageFunc)
{
yield return(TestScenarioStep.Message(new ConnectPacket
{
ClientId = ClientId,
Username = "******",
Password = "******",
WillTopicName = "last/word",
WillMessage = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes("oops"))
}));
var connAckPacket = Assert.IsType <ConnAckPacket>(currentMessageFunc());
Assert.Equal(ConnectReturnCode.Accepted, connAckPacket.ReturnCode);
int subscribePacketId = GetRandomPacketId();
int unsubscribePacketId = GetRandomPacketId();
yield return(TestScenarioStep.Messages(
new SubscribePacket(subscribePacketId,
new SubscriptionRequest(SubscribeTopicFilter1, QualityOfService.ExactlyOnce),
new SubscriptionRequest(SubscribeTopicFilter2, QualityOfService.AtLeastOnce),
new SubscriptionRequest("for/unsubscribe", QualityOfService.AtMostOnce)),
new UnsubscribePacket(unsubscribePacketId, "for/unsubscribe")));
var subAckPacket = Assert.IsType <SubAckPacket>(currentMessageFunc());
Assert.Equal(subscribePacketId, subAckPacket.PacketId);
Assert.Equal(3, subAckPacket.ReturnCodes.Count);
Assert.Equal(QualityOfService.ExactlyOnce, subAckPacket.ReturnCodes[0]);
Assert.Equal(QualityOfService.AtLeastOnce, subAckPacket.ReturnCodes[1]);
Assert.Equal(QualityOfService.AtMostOnce, subAckPacket.ReturnCodes[2]);
yield return(TestScenarioStep.MoreFeedbackExpected());
var unsubAckPacket = Assert.IsType <UnsubAckPacket>(currentMessageFunc());
Assert.Equal(unsubscribePacketId, unsubAckPacket.PacketId);
int publishQoS1PacketId = GetRandomPacketId();
yield return(TestScenarioStep.Messages(
new PublishPacket(QualityOfService.AtMostOnce, false, false)
{
TopicName = PublishC2STopic,
Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(PublishC2SQos0Payload))
},
new PublishPacket(QualityOfService.AtLeastOnce, false, false)
{
PacketId = publishQoS1PacketId,
TopicName = PublishC2SQos1Topic,
Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(PublishC2SQos1Payload))
}));
//new PublishPacket(QualityOfService.AtLeastOnce, false, false) { TopicName = "feedback/qos/One", Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes("QoS 1 test. Different data length.")) });
var pubAckPacket = Assert.IsType <PubAckPacket>(currentMessageFunc());
Assert.Equal(publishQoS1PacketId, pubAckPacket.PacketId);
yield return(TestScenarioStep.MoreFeedbackExpected());
var publishPacket = Assert.IsType <PublishPacket>(currentMessageFunc());
Assert.Equal(QualityOfService.AtLeastOnce, publishPacket.QualityOfService);
Assert.Equal(PublishS2CQos1Topic, publishPacket.TopicName);
Assert.Equal(PublishS2CQos1Payload, publishPacket.Payload.ToString(Encoding.UTF8));
yield return(TestScenarioStep.Messages(
PubAckPacket.InResponseTo(publishPacket),
DisconnectPacket.Instance));
}
public void AlreadyCompressedFrame()
{
var encoderChannel = new EmbeddedChannel(new PerMessageDeflateEncoder(9, 15, false));
// initialize
var payload = new byte[300];
_random.NextBytes(payload);
var frame = new BinaryWebSocketFrame(true,
WebSocketRsv.Rsv3 | WebSocketRsv.Rsv1, Unpooled.WrappedBuffer(payload));
// execute
Assert.True(encoderChannel.WriteOutbound(frame));
var newFrame = encoderChannel.ReadOutbound <BinaryWebSocketFrame>();
// test
Assert.NotNull(newFrame);
Assert.NotNull(newFrame.Content);
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();
}
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();
}
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 static IByteBuffer GetContent(string webSocketLocation) => Unpooled.WrappedBuffer(
Encoding.ASCII.GetBytes(
"<html><head><title>Web Socket Performance Test</title></head>" + Newline +
"<body>" + Newline +
"<h2>WebSocket Performance Test</h2>" + Newline +
"<label>Connection Status:</label>" + Newline +
"<label id=\"connectionLabel\"></label><br />" + Newline +
"<form onsubmit=\"return false;\">" + Newline +
"Message size:" +
"<input type=\"text\" id=\"messageSize\" value=\"1024\"/><br>" + Newline +
"Number of messages:" +
"<input type=\"text\" id=\"nrMessages\" value=\"100000\"/><br>" + Newline +
"Data Type:" +
"<input type=\"radio\" name=\"type\" id=\"typeText\" value=\"text\" checked>text" +
"<input type=\"radio\" name=\"type\" id=\"typeBinary\" value=\"binary\">binary<br>" + Newline +
"Mode:<br>" + Newline +
"<input type=\"radio\" name=\"mode\" id=\"modeSingle\" value=\"single\" checked>" +
"Wait for response after each messages<br>" + Newline +
"<input type=\"radio\" name=\"mode\" id=\"modeAll\" value=\"all\">" +
"Send all messages and then wait for all responses<br>" + Newline +
"<input type=\"checkbox\" id=\"verifiyResponses\">Verify responded messages<br>" + Newline +
"<input type=\"button\" value=\"Start Benchmark\"" + Newline +
" onclick=\"startBenchmark()\" />" + Newline +
"<h3>Output</h3>" + Newline +
"<textarea id=\"output\" style=\"width:500px;height:300px;\"></textarea>" + Newline +
"<br>" + Newline +
"<input type=\"button\" value=\"Clear\" onclick=\"clearText()\">" + Newline +
"</form>" + Newline +
"<script type=\"text/javascript\">" + Newline +
"var benchRunning = false;" + Newline +
"var messageSize = 0;" + Newline +
"var totalMessages = 0;" + Newline +
"var rcvdMessages = 0;" + Newline +
"var isBinary = true;" + Newline +
"var isSingle = true;" + Newline +
"var verifiyResponses = false;" + Newline +
"var benchData = null;" + Newline +
"var startTime;" + Newline +
"var endTime;" + Newline +
"var socket;" + Newline +
"var output = document.getElementById('output');" + Newline +
"var connectionLabel = document.getElementById('connectionLabel');" + Newline +
"if (!window.WebSocket) {" + Newline +
" window.WebSocket = window.MozWebSocket;" + Newline +
'}' + Newline +
"if (window.WebSocket) {" + Newline +
" socket = new WebSocket(\"" + webSocketLocation + "\");" + Newline +
" socket.binaryType = 'arraybuffer';" + Newline +
" socket.onmessage = function(event) {" + Newline +
" if (verifiyResponses) {" + Newline +
" if (isBinary) {" + Newline +
" if (!(event.data instanceof ArrayBuffer) || " + Newline +
" event.data.byteLength != benchData.byteLength) {" + Newline +
" onInvalidResponse(benchData, event.data);" + Newline +
" return;" + Newline +
" } else {" + Newline +
" var v = new Uint8Array(event.data);" + Newline +
" for (var j = 0; j < benchData.byteLength; j++) {" + Newline +
" if (v[j] != benchData[j]) {" + Newline +
" onInvalidResponse(benchData, event.data);" + Newline +
" return;" + Newline +
" }" + Newline +
" }" + Newline +
" }" + Newline +
" } else {" + Newline +
" if (event.data != benchData) {" + Newline +
" onInvalidResponse(benchData, event.data);" + Newline +
" return;" + Newline +
" }" + Newline +
" }" + Newline +
" }" + Newline +
" rcvdMessages++;" + Newline +
" if (rcvdMessages == totalMessages) {" + Newline +
" onFinished();" + Newline +
" } else if (isSingle) {" + Newline +
" socket.send(benchData);" + Newline +
" }" + Newline +
" };" + Newline +
" socket.onopen = function(event) {" + Newline +
" connectionLabel.innerHTML = \"Connected\";" + Newline +
" };" + Newline +
" socket.onclose = function(event) {" + Newline +
" benchRunning = false;" + Newline +
" connectionLabel.innerHTML = \"Disconnected\";" + Newline +
" };" + Newline +
"} else {" + Newline +
" alert(\"Your browser does not support Web Socket.\");" + Newline +
'}' + Newline +
Newline +
"function onInvalidResponse(sent,recvd) {" + Newline +
" socket.close();" + Newline +
" alert(\"Error: Sent data did not match the received data!\");" + Newline +
"}" + Newline +
Newline +
"function clearText() {" + Newline +
" output.value=\"\";" + Newline +
"}" + Newline +
Newline +
"function createBenchData() {" + Newline +
" if (isBinary) {" + Newline +
" benchData = new Uint8Array(messageSize);" + Newline +
" for (var i=0; i < messageSize; i++) {" + Newline +
" benchData[i] += Math.floor(Math.random() * 255);" + Newline +
" }" + Newline +
" } else { " + Newline +
" benchData = \"\";" + Newline +
" for (var i=0; i < messageSize; i++) {" + Newline +
" benchData += String.fromCharCode(Math.floor(Math.random() * (123 - 65) + 65));" + Newline +
" }" + Newline +
" }" + Newline +
"}" + Newline +
Newline +
"function startBenchmark(message) {" + Newline +
" if (!window.WebSocket || benchRunning) { return; }" + Newline +
" if (socket.readyState == WebSocket.OPEN) {" + Newline +
" isBinary = document.getElementById('typeBinary').checked;" + Newline +
" isSingle = document.getElementById('modeSingle').checked;" + Newline +
" verifiyResponses = document.getElementById('verifiyResponses').checked;" + Newline +
" messageSize = parseInt(document.getElementById('messageSize').value);" + Newline +
" totalMessages = parseInt(document.getElementById('nrMessages').value);" + Newline +
" if (isNaN(messageSize) || isNaN(totalMessages)) return;" + Newline +
" createBenchData();" + Newline +
" output.value = output.value + '\\nStarting Benchmark';" + Newline +
" rcvdMessages = 0;" + Newline +
" benchRunning = true;" + Newline +
" startTime = new Date();" + Newline +
" if (isSingle) {" + Newline +
" socket.send(benchData);" + Newline +
" } else {" + Newline +
" for (var i = 0; i < totalMessages; i++) socket.send(benchData);" + Newline +
" }" + Newline +
" } else {" + Newline +
" alert(\"The socket is not open.\");" + Newline +
" }" + Newline +
'}' + Newline +
Newline +
"function onFinished() {" + Newline +
" endTime = new Date();" + Newline +
" var duration = (endTime - startTime) / 1000.0;" + Newline +
" output.value = output.value + '\\nTest took: ' + duration + 's';" + Newline +
" var messagesPerS = totalMessages / duration;" + Newline +
" output.value = output.value + '\\nPerformance: ' + messagesPerS + ' Messages/s';" + Newline +
" output.value = output.value + ' in each direction';" + Newline +
" output.value = output.value + '\\nRound trip: ' + 1000.0/messagesPerS + 'ms';" + Newline +
" var throughput = messageSize * totalMessages / duration;" + Newline +
" var throughputText;" + Newline +
" if (isBinary) throughputText = throughput / (1024*1024) + ' MB/s';" + Newline +
" else throughputText = throughput / (1000*1000) + ' MChars/s';" + Newline +
" output.value = output.value + '\\nThroughput: ' + throughputText;" + Newline +
" output.value = output.value + ' in each direction';" + Newline +
" benchRunning = false;" + Newline +
"}" + Newline +
"</script>" + Newline +
"</body>" + Newline +
"</html>" + Newline));
private void ObserveOutputIdle(bool writer)
{
TimeSpan writerIdleTime = zeroSecond;
TimeSpan allIdleTime = zeroSecond;
IdleStateEvent expected;
if (writer)
{
writerIdleTime = TimeSpan.FromSeconds(5);
expected = IdleStateEvent.FirstWriterIdleStateEvent;
}
else
{
allIdleTime = TimeSpan.FromSeconds(5);
expected = IdleStateEvent.FirstAllIdleStateEvent;
}
TestableIdleStateHandler idleStateHandler = new TestableIdleStateHandler(
true, zeroSecond, writerIdleTime, allIdleTime);
var events = new List <object>();
var handler = new TestEventChannelInboundHandlerAdapter(events);
ObservableChannel channel = new ObservableChannel(idleStateHandler, handler);
try
{
// We're writing 3 messages that will be consumed at different rates!
channel.WriteAndFlushAsync(Unpooled.WrappedBuffer(new byte[] { 1 }));
channel.WriteAndFlushAsync(Unpooled.WrappedBuffer(new byte[] { 2 }));
channel.WriteAndFlushAsync(Unpooled.WrappedBuffer(new byte[] { 3 }));
// Establish a baseline. We're not consuming anything and let it idle once.
idleStateHandler.TickRun();
Assert.Equal(1, events.Count);
Assert.Same(expected, events[0]);
events.Clear();
// Our ticker should be at second 5
Assert.Equal(TimeSpan.FromSeconds(5), idleStateHandler.Tick);
// Consume one message in 4 seconds, then be idle for 2 seconds,
// then run the task and we shouldn't get an IdleStateEvent because
// we haven't been idle for long enough!
idleStateHandler.DoTick(TimeSpan.FromSeconds(4));
AssertNotNullAndRelease(channel.Consume());
idleStateHandler.TickRun(TimeSpan.FromSeconds(2));
Assert.Equal(0, events.Count);
Assert.Equal(TimeSpan.FromSeconds(11), idleStateHandler.Tick); // 5s + 4s + 2s
// Consume one message in 3 seconds, then be idle for 4 seconds,
// then run the task and we shouldn't get an IdleStateEvent because
// we haven't been idle for long enough!
idleStateHandler.DoTick(TimeSpan.FromSeconds(3));
AssertNotNullAndRelease(channel.Consume());
idleStateHandler.TickRun(TimeSpan.FromSeconds(4));
Assert.Equal(0, events.Count);
Assert.Equal(TimeSpan.FromSeconds(18), idleStateHandler.Tick); // 11s + 3s + 4s
// Don't consume a message and be idle for 5 seconds.
// We should get an IdleStateEvent!
idleStateHandler.TickRun(TimeSpan.FromSeconds(5));
Assert.Equal(1, events.Count);
Assert.Equal(TimeSpan.FromSeconds(23), idleStateHandler.Tick); // 18s + 5s
events.Clear();
// Consume one message in 2 seconds, then be idle for 1 seconds,
// then run the task and we shouldn't get an IdleStateEvent because
// we haven't been idle for long enough!
idleStateHandler.DoTick(TimeSpan.FromSeconds(2));
AssertNotNullAndRelease(channel.Consume());
idleStateHandler.TickRun(TimeSpan.FromSeconds(1));
Assert.Equal(0, events.Count);
Assert.Equal(TimeSpan.FromSeconds(26), idleStateHandler.Tick); // 23s + 2s + 1s
// There are no messages left! Advance the ticker by 3 seconds,
// attempt a consume() but it will be null, then advance the
// ticker by an another 2 seconds and we should get an IdleStateEvent
// because we've been idle for 5 seconds.
idleStateHandler.DoTick(TimeSpan.FromSeconds(3));
Assert.Null(channel.Consume());
idleStateHandler.TickRun(TimeSpan.FromSeconds(2));
Assert.Equal(1, events.Count);
Assert.Equal(TimeSpan.FromSeconds(31), idleStateHandler.Tick); // 26s + 3s + 2s
// q.e.d.
}
finally
{
channel.FinishAndReleaseAll();
}
}
static async Task Main(string[] args)
{
var builder = new UriBuilder
{
Scheme = ClientSettings.IsSsl ? "wss" : "ws",
Host = ClientSettings.Host.ToString(),
Port = ClientSettings.Port,
};
string path = ExampleHelper.Configuration["path"];
builder.Path = !string.IsNullOrEmpty(path) ? path : WEBSOCKET_PATH;
Uri uri = builder.Uri;
ExampleHelper.SetConsoleLogger();
bool useLibuv = ClientSettings.UseLibuv;
Console.WriteLine("Transport type : " + (useLibuv ? "Libuv" : "Socket"));
IEventLoopGroup group;
if (useLibuv)
{
group = new EventLoopGroup();
}
else
{
group = new MultithreadEventLoopGroup();
}
X509Certificate2 cert = null;
string targetHost = null;
if (ClientSettings.IsSsl)
{
cert = new X509Certificate2(Path.Combine(ExampleHelper.ProcessDirectory, "dotnetty.com.pfx"), "password");
targetHost = cert.GetNameInfo(X509NameType.DnsName, false);
}
try
{
var bootstrap = new Bootstrap();
bootstrap
.Group(group)
.Option(ChannelOption.TcpNodelay, true);
if (useLibuv)
{
bootstrap.Channel <TcpChannel>();
}
else
{
bootstrap.Channel <TcpSocketChannel>();
}
// Connect with V13 (RFC 6455 aka HyBi-17). You can change it to V08 or V00.
// If you change it to V00, ping is not supported and remember to change
// HttpResponseDecoder to WebSocketHttpResponseDecoder in the pipeline.
WebSocketClientHandler handler =
new WebSocketClientHandler(
WebSocketClientHandshakerFactory.NewHandshaker(
uri, WebSocketVersion.V13, null, true, new DefaultHttpHeaders()));
bootstrap.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
if (cert != null)
{
pipeline.AddLast("tls", new TlsHandler(new ClientTlsSettings(targetHost).AllowAnyServerCertificate()));
}
pipeline.AddLast("idleStateHandler", new IdleStateHandler(0, 0, 60));
pipeline.AddLast(new LoggingHandler("CONN"));
pipeline.AddLast(
new HttpClientCodec(),
new HttpObjectAggregator(8192),
WebSocketClientCompressionHandler.Instance,
//new WebSocketClientProtocolHandler(
// webSocketUrl: uri,
// version: WebSocketVersion.V13,
// subprotocol: null,
// allowExtensions: true,
// customHeaders: new DefaultHttpHeaders(),
// maxFramePayloadLength: 65536,
// handleCloseFrames: true,
// performMasking: false,
// allowMaskMismatch: true,
// enableUtf8Validator: false),
new WebSocketFrameAggregator(65536),
handler);
}));
try
{
IChannel ch = await bootstrap.ConnectAsync(new IPEndPoint(ClientSettings.Host, ClientSettings.Port));
await handler.HandshakeCompletion;
Console.WriteLine("WebSocket handshake completed.\n");
Console.WriteLine("\t[bye]:Quit \n\t [ping]:Send ping frame\n\t Enter any text and Enter: Send text frame");
while (true)
{
string msg = Console.ReadLine();
if (msg == null)
{
break;
}
msg = msg.ToLowerInvariant();
switch (msg)
{
case "bye":
await ch.WriteAndFlushAsync(new CloseWebSocketFrame());
goto CloseLable;
case "ping":
var ping = new PingWebSocketFrame(Unpooled.WrappedBuffer(new byte[] { 8, 1, 8, 1 }));
await ch.WriteAndFlushAsync(ping);
break;
case "this is a test":
await ch.WriteAndFlushManyAsync(
new TextWebSocketFrame(false, "this "),
new ContinuationWebSocketFrame(false, "is "),
new ContinuationWebSocketFrame(false, "a "),
new ContinuationWebSocketFrame(true, "test")
);
break;
case "this is a error":
await ch.WriteAndFlushAsync(new TextWebSocketFrame(false, "this "));
await ch.WriteAndFlushAsync(new ContinuationWebSocketFrame(false, "is "));
await ch.WriteAndFlushAsync(new ContinuationWebSocketFrame(false, "a "));
await ch.WriteAndFlushAsync(new TextWebSocketFrame(true, "error"));
break;
default:
await ch.WriteAndFlushAsync(new TextWebSocketFrame(msg));
break;
}
}
CloseLable:
await ch.CloseAsync();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
Console.WriteLine("按任意键退出");
Console.ReadKey();
}
}
finally
{
await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1));
}
}
private static IByteBuffer Buf(byte[] bytes)
{
return(Unpooled.WrappedBuffer(bytes));
}
public void RmiMessage(IChannelHandlerContext context, RmiMessage message, RecvContext recvContext)
{
recvContext.Message = Unpooled.WrappedBuffer(message.Data);
context.FireChannelRead(recvContext);
}
public Task WriteToChannelAsync(EmbeddedChannel channel, ArraySegment <byte> input)
{
channel.WriteInbound(Unpooled.WrappedBuffer(input.Array, input.Offset, input.Count));
return(TaskUtil.Completed);
}
public void FragmentedFrameWithLeftOverInLastFragment()
{
string hexDump = "677170647a777a737574656b707a787a6f6a7561756578756f6b7868616371716c657a6d64697479766d726f6" +
"269746c6376777464776f6f72767a726f64667278676764687775786f6762766d776d706b76697773777a7072" +
"6a6a737279707a7078697a6c69616d7461656d646278626d786f66666e686e776a7a7461746d7a776668776b6" +
"f6f736e73746575637a6d727a7175707a6e74627578687871767771697a71766c64626d78726d6d7675756877" +
"62667963626b687a726d676e646263776e67797264706d6c6863626577616967706a78636a72697464756e627" +
"977616f79736475676f76736f7178746a7a7479626c64636b6b6778637768746c62";
EmbeddedChannel encoderChannel = new EmbeddedChannel(
ZlibCodecFactory.NewZlibEncoder(ZlibWrapper.None, 9, 15, 8));
EmbeddedChannel decoderChannel = new EmbeddedChannel(new PerMessageDeflateDecoder(false));
IByteBuffer originPayload = Unpooled.WrappedBuffer(StringUtil.DecodeHexDump(hexDump));
Assert.True(encoderChannel.WriteOutbound(originPayload.Duplicate().Retain()));
var compressedPayload = encoderChannel.ReadOutbound <IByteBuffer>();
compressedPayload = compressedPayload.Slice(0, compressedPayload.ReadableBytes - 4);
int oneThird = compressedPayload.ReadableBytes / 3;
TextWebSocketFrame compressedFrame1 = new TextWebSocketFrame(
false, WebSocketRsv.Rsv1, compressedPayload.Slice(0, oneThird));
ContinuationWebSocketFrame compressedFrame2 = new ContinuationWebSocketFrame(
false, WebSocketRsv.Rsv3, compressedPayload.Slice(oneThird, oneThird));
ContinuationWebSocketFrame compressedFrame3 = new ContinuationWebSocketFrame(
false, WebSocketRsv.Rsv3, compressedPayload.Slice(oneThird * 2, oneThird));
int offset = oneThird * 3;
ContinuationWebSocketFrame compressedFrameWithExtraData = new ContinuationWebSocketFrame(
true, WebSocketRsv.Rsv3, compressedPayload.Slice(offset,
compressedPayload.ReadableBytes - offset));
// check that last fragment contains only one extra byte
Assert.Equal(1, compressedFrameWithExtraData.Content.ReadableBytes);
Assert.Equal(1, compressedFrameWithExtraData.Content.GetByte(0));
// write compressed frames
Assert.True(decoderChannel.WriteInbound(compressedFrame1.Retain()));
Assert.True(decoderChannel.WriteInbound(compressedFrame2.Retain()));
Assert.True(decoderChannel.WriteInbound(compressedFrame3.Retain()));
Assert.True(decoderChannel.WriteInbound(compressedFrameWithExtraData));
// read uncompressed frames
TextWebSocketFrame uncompressedFrame1 = decoderChannel.ReadInbound <TextWebSocketFrame>();
ContinuationWebSocketFrame uncompressedFrame2 = decoderChannel.ReadInbound <ContinuationWebSocketFrame>();
ContinuationWebSocketFrame uncompressedFrame3 = decoderChannel.ReadInbound <ContinuationWebSocketFrame>();
ContinuationWebSocketFrame uncompressedExtraData = decoderChannel.ReadInbound <ContinuationWebSocketFrame>();
Assert.False(uncompressedExtraData.Content.IsReadable());
var uncompressedPayload = Unpooled.WrappedBuffer(uncompressedFrame1.Content, uncompressedFrame2.Content,
uncompressedFrame3.Content, uncompressedExtraData.Content);
Assert.Equal(originPayload, uncompressedPayload);
Assert.True(originPayload.Release());
Assert.True(uncompressedPayload.Release());
Assert.True(encoderChannel.FinishAndReleaseAll());
Assert.False(decoderChannel.Finish());
}
static async Task RunClientAsync()
{
var builder = new UriBuilder
{
Scheme = ClientSettings.IsSsl ? "wss" : "ws",
Host = ClientSettings.Host.ToString(),
Port = ClientSettings.Port
};
string path = ExampleHelper.Configuration["path"];
if (!string.IsNullOrEmpty(path))
{
builder.Path = path;
}
Uri uri = builder.Uri;
ExampleHelper.SetConsoleLogger();
bool useLibuv = ClientSettings.UseLibuv;
Console.WriteLine("Transport type : " + (useLibuv ? "Libuv" : "Socket"));
IEventLoopGroup group;
if (useLibuv)
{
group = new EventLoopGroup();
}
else
{
group = new MultithreadEventLoopGroup();
}
X509Certificate2 cert = null;
string targetHost = null;
if (ClientSettings.IsSsl)
{
cert = new X509Certificate2(Path.Combine(ExampleHelper.ProcessDirectory, "dotnetty.com.pfx"), "password");
targetHost = cert.GetNameInfo(X509NameType.DnsName, false);
}
try
{
var bootstrap = new Bootstrap();
bootstrap
.Group(group)
.Option(ChannelOption.TcpNodelay, true);
if (useLibuv)
{
bootstrap.Channel <TcpChannel>();
}
else
{
bootstrap.Channel <TcpSocketChannel>();
}
// Connect with V13 (RFC 6455 aka HyBi-17). You can change it to V08 or V00.
// If you change it to V00, ping is not supported and remember to change
// HttpResponseDecoder to WebSocketHttpResponseDecoder in the pipeline.
var handler = new WebSocketClientHandler(
WebSocketClientHandshakerFactory.NewHandshaker(
uri, WebSocketVersion.V13, null, true, new DefaultHttpHeaders()));
bootstrap.Handler(new ActionChannelInitializer <IChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
if (cert != null)
{
pipeline.AddLast("tls", new TlsHandler(stream => new SslStream(stream, true, (sender, certificate, chain, errors) => true), new ClientTlsSettings(targetHost)));
}
pipeline.AddLast(
new HttpClientCodec(),
new HttpObjectAggregator(8192),
WebSocketClientCompressionHandler.Instance,
handler);
}));
IChannel ch = await bootstrap.ConnectAsync(new IPEndPoint(ClientSettings.Host, ClientSettings.Port));
await handler.HandshakeCompletion;
Console.WriteLine("WebSocket handshake completed.\n");
Console.WriteLine("\t[bye]:Quit \n\t [ping]:Send ping frame\n\t Enter any text and Enter: Send text frame");
while (true)
{
string msg = Console.ReadLine();
if (msg == null)
{
break;
}
else if ("bye".Equals(msg.ToLower()))
{
await ch.WriteAndFlushAsync(new CloseWebSocketFrame());
break;
}
else if ("ping".Equals(msg.ToLower()))
{
var frame = new PingWebSocketFrame(Unpooled.WrappedBuffer(new byte[] { 8, 1, 8, 1 }));
await ch.WriteAndFlushAsync(frame);
}
else
{
WebSocketFrame frame = new TextWebSocketFrame(msg);
await ch.WriteAndFlushAsync(frame);
}
}
await ch.CloseAsync();
}
finally
{
await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1));
}
}
public DatagramPacket Create(byte[] message, EndPoint recipient)
{
return(new DatagramPacket(Unpooled.WrappedBuffer(message), recipient));
}
async Task GetPart1SpecificSteps(IChannel channel, ReadListeningHandler readHandler)
{
int publishQoS1PacketId = GetRandomPacketId();
await channel.WriteAndFlushManyAsync(
new PublishPacket(QualityOfService.AtMostOnce, false, false)
{
//TopicName = string.Format("devices/{0}/messages/log/verbose/", clientId),
TopicName = $"devices/{this.clientId}/messages/events",
Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes("{\"test\": \"telemetry-QoS0\"}"))
},
new PublishPacket(QualityOfService.AtLeastOnce, false, false)
{
PacketId = publishQoS1PacketId,
TopicName = $"devices/{this.clientId}/messages/events",
Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes("{\"test\": \"telemetry\"}"))
});
Packet[] packets = (await Task.WhenAll(Enumerable.Repeat(0, 5).Select(_ => readHandler.ReceiveAsync())))
.Select(Assert.IsAssignableFrom <Packet>)
.ToArray();
PubAckPacket pubAckPacket = Assert.Single(packets.OfType <PubAckPacket>());
Assert.Equal(publishQoS1PacketId, pubAckPacket.PacketId);
PublishPacket publishQoS0Packet = Assert.Single(packets.OfType <PublishPacket>().Where(x => x.QualityOfService == QualityOfService.AtMostOnce));
this.AssertPacketCoreValue(publishQoS0Packet, NotificationQoS0Content);
PublishPacket publishQoS1Packet = Assert.Single(packets.OfType <PublishPacket>().Where(x => x.QualityOfService == QualityOfService.AtLeastOnce));
this.AssertPacketCoreValue(publishQoS1Packet, NotificationQoS1Content);
PublishPacket[] publishQoS2Packets = packets.OfType <PublishPacket>().Where(x => x.QualityOfService == QualityOfService.ExactlyOnce).ToArray();
Assert.Equal(2, publishQoS2Packets.Length);
PublishPacket publishQoS2Packet1 = publishQoS2Packets[0];
this.AssertPacketCoreValue(publishQoS2Packet1, NotificationQoS2Content);
PublishPacket publishQoS2Packet2 = publishQoS2Packets[1];
this.AssertPacketCoreValue(publishQoS2Packet2, NotificationQoS2Content2);
await channel.WriteAndFlushManyAsync(
PubAckPacket.InResponseTo(publishQoS1Packet),
PubRecPacket.InResponseTo(publishQoS2Packet1),
PubRecPacket.InResponseTo(publishQoS2Packet2));
var pubRelQoS2Packet1 = Assert.IsAssignableFrom <PubRelPacket>(await readHandler.ReceiveAsync());
Assert.Equal(publishQoS2Packet1.PacketId, pubRelQoS2Packet1.PacketId);
var pubRelQoS2Packet2 = Assert.IsAssignableFrom <PubRelPacket>(await readHandler.ReceiveAsync());
Assert.Equal(publishQoS2Packet2.PacketId, pubRelQoS2Packet2.PacketId);
await channel.WriteAndFlushManyAsync(
PubCompPacket.InResponseTo(pubRelQoS2Packet1),
DisconnectPacket.Instance);
// device queue still contains QoS 2 packet 2 which was PUBRECed but not PUBCOMPed.
}
public async Task SendAsync(EndPoint endPoint, byte[] bytes)
{
var buffer = Unpooled.WrappedBuffer(bytes);
var dp = new DatagramPacket(buffer, endPoint);
await channel.WriteAndFlushAsync(dp);
}
public TarsInputStream(byte[] bs, int pos)
{
buffer = Unpooled.WrappedBuffer(bs);
buffer.SkipBytes(pos);
}
public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
{
try
{
ResponseModel response = null;
IChannel client = null;
try
{
client = AsyncHelpers.RunSync(() => _bootstrap.ConnectAsync($"{ServerIp}:{ServerPort}".ToIPEndPoint()));
}
catch
{
throw new Exception("连接到服务端失败!");
}
if (client != null)
{
_clientWait.Start(client.Id.AsShortText());
RequestModel requestModel = new RequestModel
{
ServiceName = ServiceName,
MethodName = binder.Name,
Paramters = args.ToList()
};
var sendBuffer = Unpooled.WrappedBuffer(requestModel.ToJson().ToBytes(Encoding.UTF8));
client.WriteAndFlushAsync(sendBuffer);
var responseStr = _clientWait.Wait(client.Id.AsShortText()).ResponseString;
response = responseStr.ToObject <ResponseModel>();
}
else
{
throw new Exception("连接到服务端失败!");
}
if (response == null)
{
throw new Exception("服务器超时未响应");
}
else if (response.Success)
{
Type returnType = ServiceType.GetMethod(binder.Name).ReturnType;
if (returnType == typeof(void))
{
result = null;
}
else
{
result = response.Data.ToObject(returnType);
}
return(true);
}
else
{
throw new Exception($"服务器异常，错误消息：{response.Msg}");
}
}
catch (Exception ex)
{
throw ex;
}
}
public void Wrap(byte[] bs) => buffer = Unpooled.WrappedBuffer(bs);
public void NotEqualsBufferUnderflow()
{
var b1 = new byte[8];
var b2 = new byte[16];
var rand = new Random();
rand.NextBytes(b1);
rand.NextBytes(b2);
int iB1 = b1.Length / 2;
int iB2 = iB1 + b1.Length;
int length = b1.Length - iB1;
Array.Copy(b1, iB1, b2, iB2, length - 1);
Assert.Throws <ArgumentException>(() => ByteBufferUtil.Equals(Unpooled.WrappedBuffer(b1), iB1, Unpooled.WrappedBuffer(b2), iB2, -1));
}
/// <summary>
/// Gets the byte buffer.
/// </summary>
/// <param name="message">The message.</param>
/// <returns>IByteBuffer.</returns>
protected IByteBuffer GetByteBuffer(TransportMessage message)
{
var data = message.GetContent <byte[]>();
return(Unpooled.WrappedBuffer(data));
}
public async Task EchoServerAndClient()
{
var testPromise = new TaskCompletionSource();
var tlsCertificate = TestResourceHelper.GetTestCertificate();
Func <Task> closeServerFunc = await this.StartServerAsync(true, ch =>
{
ch.Pipeline.AddLast("server logger", new LoggingHandler("SERVER"));
ch.Pipeline.AddLast("server tls", TlsHandler.Server(tlsCertificate));
ch.Pipeline.AddLast("server logger2", new LoggingHandler("SER***"));
ch.Pipeline.AddLast("server prepender", new LengthFieldPrepender(2));
ch.Pipeline.AddLast("server decoder", new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2));
ch.Pipeline.AddLast(new EchoChannelHandler());
}, testPromise);
var group = new MultithreadEventLoopGroup();
var readListener = new ReadListeningHandler(DefaultTimeout);
Bootstrap b = new Bootstrap()
.Group(group)
.Channel <TcpSocketChannel>()
.Option(ChannelOption.TcpNodelay, true)
.Handler(new ActionChannelInitializer <ISocketChannel>(ch =>
{
string targetHost = tlsCertificate.GetNameInfo(X509NameType.DnsName, false);
var clientTlsSettings = new ClientTlsSettings(targetHost);
ch.Pipeline.AddLast("client logger", new LoggingHandler("CLIENT"));
ch.Pipeline.AddLast("client tls", new TlsHandler(stream => new SslStream(stream, true, (sender, certificate, chain, errors) => true), clientTlsSettings));
ch.Pipeline.AddLast("client logger2", new LoggingHandler("CLI***"));
ch.Pipeline.AddLast("client prepender", new LengthFieldPrepender(2));
ch.Pipeline.AddLast("client decoder", new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2));
ch.Pipeline.AddLast(readListener);
}));
this.Output.WriteLine("Configured Bootstrap: {0}", b);
IChannel clientChannel = null;
try
{
clientChannel = await b.ConnectAsync(IPAddress.Loopback, Port);
this.Output.WriteLine("Connected channel: {0}", clientChannel);
string[] messages = { "message 1", string.Join(",", Enumerable.Range(1, 300)) };
foreach (string message in messages)
{
await clientChannel.WriteAndFlushAsync(Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(message))).WithTimeout(DefaultTimeout);
var responseMessage = Assert.IsAssignableFrom <IByteBuffer>(await readListener.ReceiveAsync());
Assert.Equal(message, responseMessage.ToString(Encoding.UTF8));
}
testPromise.TryComplete();
await testPromise.Task.WithTimeout(TimeSpan.FromSeconds(30));
}
finally
{
Task serverCloseTask = closeServerFunc();
clientChannel?.CloseAsync().Wait(TimeSpan.FromSeconds(5));
group.ShutdownGracefullyAsync().Wait(TimeSpan.FromSeconds(5));
if (!serverCloseTask.Wait(ShutdownTimeout))
{
this.Output.WriteLine("Didn't stop in time.");
}
}
}
public void WrappedBuffer()
{
var bytes = new byte[16];
IByteBuffer a = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(bytes));
Assert.Equal(16, a.Capacity);
a.Release();
a = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 }));
IByteBuffer b = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[][] { new byte[] { 1, 2, 3 } }));
Assert.Equal(a, b);
a.Release();
b.Release();
a = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 }));
b = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(
new byte[] { 1 },
new byte[] { 2 },
new byte[] { 3 }));
Assert.Equal(a, b);
a.Release();
b.Release();
a = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 }));
b = Unpooled.WrappedBuffer(new[] {
Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 })
});
Assert.Equal(a, b);
a.Release();
b.Release();
a = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 }));
b = Unpooled.WrappedBuffer(
Unpooled.WrappedBuffer(new byte[] { 1 }),
Unpooled.WrappedBuffer(new byte[] { 2 }),
Unpooled.WrappedBuffer(new byte[] { 3 }));
Assert.Equal(a, b);
a.Release();
b.Release();
a = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 }));
b = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new[] {
Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 })
}));
Assert.Equal(a, b);
a.Release();
b.Release();
a = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(new byte[] { 1, 2, 3 }));
b = Unpooled.WrappedBuffer(Unpooled.WrappedBuffer(
Unpooled.WrappedBuffer(new byte[] { 1 }),
Unpooled.WrappedBuffer(new byte[] { 2 }),
Unpooled.WrappedBuffer(new byte[] { 3 })));
Assert.Equal(a, b);
a.Release();
b.Release();
}