public LitePacketParserWithCustomProcessor()
{
var connection = new Mock <ILiteConnection>();
_token = new LiteDataToken(connection.Object);
_packetParser = new LitePacketParser(new CustomVariablePacketProcessor());
}
public void ParseIncomingDataWithInvalidSizeTest()
{
_packetParser = new LitePacketParser(_packetProcessor);
var token = new LiteDataToken();
Assert.Throws <InvalidOperationException>(() => _packetParser.ParseIncomingData(token, _invalidBuffer, 32));
}
public void ParseIncomingDataWithHeaderTest(int bytesTransfered)
{
_packetParser = new LitePacketParser(new DefaultLitePacketProcessor(includeHeader: true));
var connection = new Mock <ILiteConnection>();
var token = new LiteDataToken(connection.Object);
var numberOfReceivesNeeded = _buffer.Length / bytesTransfered + 1;
var receviedMessages = new List <byte[]>();
for (var i = 0; i < numberOfReceivesNeeded; i++)
{
var incomingBuffer = _buffer.Skip(i * bytesTransfered).Take(bytesTransfered).ToArray();
IEnumerable <byte[]> messages = _packetParser.ParseIncomingData(token, incomingBuffer, Math.Min(bytesTransfered, incomingBuffer.Length));
if (messages.Any())
{
receviedMessages.AddRange(messages);
}
}
Assert.Single(receviedMessages);
var messageContent = Encoding.UTF8.GetString(_buffer);
Assert.Equal(messageContent, Encoding.UTF8.GetString(receviedMessages.Single().ToArray()));
}
public override bool ParseHeader(LiteDataToken token, byte[] buffer, int bytesTransfered)
{
int bufferRemainingBytes = bytesTransfered - token.DataStartOffset;
if (bufferRemainingBytes <= 0)
{
return(false);
}
var data = new List <byte>();
int numRead = 0;
byte read;
do
{
read = buffer[token.DataStartOffset++];
int value = (read & 0b01111111);
data.Add((byte)(value << (7 * numRead)));
numRead++;
if (numRead > 5)
{
throw new InvalidOperationException("VarInt32 is too big.");
}
} while ((read & 0b10000000) != 0);
token.HeaderData = token.HeaderData is null?data.ToArray() : token.HeaderData.Concat(data).ToArray();
return(true);
}
/// <summary>
/// Parses incoming buffer for a specified connection.
/// </summary>
/// <param name="token">Client token information.</param>
/// <param name="buffer">Received buffer.</param>
/// <param name="bytesTransfered">Number of bytes transfered throught the network.</param>
/// <returns>A collection containing all messages as byte arrays.</returns>
public IEnumerable <byte[]> ParseIncomingData(LiteDataToken token, byte[] buffer, int bytesTransfered)
{
var messages = new List <byte[]>();
while (token.DataStartOffset < bytesTransfered)
{
if (!token.IsHeaderComplete)
{
token.IsHeaderComplete = _packetProcessor.ParseHeader(token, buffer, bytesTransfered);
}
if (token.IsHeaderComplete && token.HeaderData is not null)
{
_packetProcessor.ParseContent(token, buffer, bytesTransfered);
}
if (token.IsMessageComplete)
{
messages.Add(BuildClientMessageData(token));
token.Reset();
}
}
token.DataStartOffset = 0;
return(messages);
}
/// <summary>
/// Creates a new <see cref="LiteDefaultConnectionToken"/> instance with a <see cref="ILiteConnection"/>.
/// </summary>
/// <param name="connection">Current connection.</param>
/// <param name="handlerAction">Action to execute when a packet message is being processed.</param>
public LiteQueuedConnectionToken(ILiteConnection connection, Action <ILiteConnection, byte[]> handlerAction)
{
Connection = connection;
_handlerAction = handlerAction;
DataToken = new LiteDataToken(Connection);
_receiveMessageQueue = new BlockingCollection <byte[]>();
_receiveCancellationTokenSource = new CancellationTokenSource();
_receiveCancellationToken = _receiveCancellationTokenSource.Token;
Task.Factory.StartNew(OnProcessMessageQueue,
_receiveCancellationToken,
TaskCreationOptions.LongRunning,
TaskScheduler.Default);
}
public void ParseIncomingDataTest(int bytesTransfered)
{
_packetParser = new LitePacketParser(_packetProcessor);
var token = new LiteDataToken();
var numberOfReceivesNeeded = _buffer.Length / bytesTransfered + 1;
var receviedMessages = new List <byte[]>();
for (var i = 0; i < numberOfReceivesNeeded; i++)
{
var incomingBuffer = _buffer.Skip(i * bytesTransfered).Take(bytesTransfered).ToArray();
IEnumerable <byte[]> messages = _packetParser.ParseIncomingData(token, incomingBuffer, Math.Min(bytesTransfered, incomingBuffer.Length));
if (messages.Any())
{
receviedMessages.AddRange(messages);
}
}
Assert.Single(receviedMessages);
Assert.Equal(_messageContent, Encoding.UTF8.GetString(receviedMessages.Single().Skip(sizeof(int)).ToArray()));
}
/// <summary>
/// Builds the received message data based on the given data token.
/// </summary>
/// <param name="token">Client data token.</param>
/// <returns>Client received data.</returns>
private byte[] BuildClientMessageData(LiteDataToken token)
{
if (token.MessageSize is null)
{
throw new ArgumentNullException("An error occurred: Message size cannot be null.");
}
var bufferSize = _packetProcessor.IncludeHeader ? _packetProcessor.HeaderSize + token.MessageSize.Value : token.MessageSize.Value;
var buffer = new byte[bufferSize];
if (_packetProcessor.IncludeHeader)
{
Array.Copy(token.HeaderData, 0, buffer, 0, _packetProcessor.HeaderSize);
Array.Copy(token.MessageData, 0, buffer, _packetProcessor.HeaderSize, token.MessageSize.Value);
}
else
{
Array.Copy(token.MessageData, 0, buffer, 0, token.MessageSize.Value);
}
return(buffer);
}
/// <summary>
/// Creates a new <see cref="LiteDefaultConnectionToken"/> instance with a <see cref="ILiteConnection"/>.
/// </summary>
/// <param name="connection">Current connection.</param>
/// <param name="handlerAction">Action to execute when a packet message is being processed.</param>
public LiteDefaultConnectionToken(ILiteConnection connection, Action <ILiteConnection, byte[]> handlerAction)
{
Connection = connection;
_handlerAction = handlerAction;
DataToken = new LiteDataToken();
}
public LitePacketParserWithCustomProcessor()
{
_token = new LiteDataToken();
_packetParser = new LitePacketParser(new CustomVariablePacketProcessor());
}
