private async Task ProcessMessage(IConnectionInfo info, TmqMessage message, TmqServerSocket socket)
{
//if user makes a mistake in received method, we should not interrupt connection handling
try
{
socket.KeepAlive();
await _handler.Received(_server, info, socket, message);
}
catch (Exception e)
{
if (_server.Logger != null)
{
_server.Logger.LogException("Unhandled Exception", e);
}
}
}
private async Task <bool> ReadContent(TmqMessage message, Stream stream)
{
if (message.MessageIdLength > 0)
{
message.MessageId = await ReadOctetSizeData(stream, message.MessageIdLength);
}
if (message.SourceLength > 0)
{
message.Source = await ReadOctetSizeData(stream, message.SourceLength);
}
if (message.TargetLength > 0)
{
message.Target = await ReadOctetSizeData(stream, message.TargetLength);
}
if (message.Length == 0)
{
return(true);
}
if (message.Content == null)
{
message.Content = new MemoryStream();
}
ulong left = message.Length;
ulong blen = (ulong)_buffer.Length;
do
{
int rcount = (int)(left > blen ? blen : left);
int read = await stream.ReadAsync(_buffer, 0, rcount);
if (read == 0)
{
return(false);
}
left -= (uint)read;
await message.Content.WriteAsync(_buffer, 0, read);
} while (left > 0);
return(true);
}
/// <summary>
/// Reads TMQ message from stream
/// </summary>
public async Task <TmqMessage> Read(Stream stream)
{
byte[] bytes = new byte[REQUIRED_SIZE];
bool done = await ReadCertainBytes(stream, bytes, 0, REQUIRED_SIZE);
if (!done)
{
return(null);
}
TmqMessage message = new TmqMessage();
done = await ProcessRequiredFrame(message, bytes, stream);
if (!done)
{
return(null);
}
if (DecreaseTTL)
{
message.Ttl--;
}
bool success = await ReadContent(message, stream);
if (!success)
{
return(null);
}
if (message.Content != null && message.Content.Position > 0)
{
message.Content.Position = 0;
}
return(message);
}
private static async Task <bool> ProcessRequiredFrame(TmqMessage message, byte[] bytes, Stream stream)
{
byte type = bytes[0];
if (type >= 128)
{
message.FirstAcquirer = true;
type -= 128;
}
if (type >= 64)
{
message.HighPriority = true;
type -= 64;
}
message.Type = (MessageType)type;
byte ttl = bytes[1];
if (ttl >= 128)
{
message.ResponseRequired = true;
ttl -= 128;
}
if (ttl >= 64)
{
message.AcknowledgeRequired = true;
ttl -= 64;
}
message.Ttl = ttl;
message.MessageIdLength = bytes[2];
message.SourceLength = bytes[3];
message.TargetLength = bytes[4];
message.ContentType = BitConverter.ToUInt16(bytes, 5);
byte length = bytes[7];
if (length == 253)
{
bool done = await ReadCertainBytes(stream, bytes, 0, 2);
if (!done)
{
return(false);
}
message.Length = BitConverter.ToUInt16(bytes, 0);
}
else if (length == 254)
{
bool done = await ReadCertainBytes(stream, bytes, 0, 4);
if (!done)
{
return(false);
}
message.Length = BitConverter.ToUInt32(bytes, 0);
}
else if (length == 255)
{
byte[] b = new byte[8];
bool done = await ReadCertainBytes(stream, b, 0, 8);
if (!done)
{
return(false);
}
message.Length = BitConverter.ToUInt64(b, 0);
}
else
{
message.Length = length;
}
return(true);
}
/// <summary>
/// Writes frame to stream
/// </summary>
private static async Task WriteFrame(MemoryStream ms, TmqMessage message)
{
byte type = (byte)message.Type;
if (message.FirstAcquirer)
{
type += 128;
}
if (message.HighPriority)
{
type += 64;
}
ms.WriteByte(type);
byte ttl = (byte)message.Ttl;
if (ttl > 63)
{
ttl = 63;
}
if (message.ResponseRequired)
{
ttl += 128;
}
if (message.AcknowledgeRequired)
{
ttl += 64;
}
ms.WriteByte(ttl);
ms.WriteByte((byte)message.MessageIdLength);
ms.WriteByte((byte)message.SourceLength);
ms.WriteByte((byte)message.TargetLength);
await ms.WriteAsync(BitConverter.GetBytes(message.ContentType));
if (message.Content != null && message.Length == 0)
{
message.Length = (ulong)message.Content.Length;
}
if (message.Length < 253)
{
ms.WriteByte((byte)message.Length);
}
else if (message.Length <= ushort.MaxValue)
{
ms.WriteByte(253);
await ms.WriteAsync(BitConverter.GetBytes((ushort)message.Length));
}
else if (message.Length <= uint.MaxValue)
{
ms.WriteByte(254);
await ms.WriteAsync(BitConverter.GetBytes((uint)message.Length));
}
else
{
ms.WriteByte(255);
await ms.WriteAsync(BitConverter.GetBytes(message.Length));
}
if (message.MessageIdLength > 0)
{
byte[] bytes = Encoding.UTF8.GetBytes(message.MessageId);
await ms.WriteAsync(bytes);
}
if (message.SourceLength > 0)
{
byte[] bytes = Encoding.UTF8.GetBytes(message.Source);
await ms.WriteAsync(bytes);
}
if (message.TargetLength > 0)
{
byte[] bytes = Encoding.UTF8.GetBytes(message.Target);
await ms.WriteAsync(bytes);
}
}
/// <summary>
/// Creates byte array of only TMQ message content
/// </summary>
public async Task <byte[]> CreateContent(TmqMessage value)
{
await using MemoryStream ms = new MemoryStream();
WriteContent(ms, value);
return(ms.ToArray());
}
