public static RawMessage ReadFromWithoutHeader(Stream buffer)
{
var header = RawMessageHeader.From(0, 0, buffer.Length);
var message = new RawMessage(header, header.Length);
message.PutRemaining(buffer);
return(message);
}
public static RawMessage From(int nodeId, int type, string textMessage)
{
var textBytes = Converters.TextToBytes(textMessage);
var header = RawMessageHeader.From(nodeId, type, textBytes.Length);
var message = new RawMessage(header, textBytes.Length);
message.Append(textBytes, 0, textBytes.Length);
return(message);
}
private void PrepareRawMessage(int position, long bytesToAppend)
{
var inboundHeader = new RawMessageHeader(_node1.Id.Value, (short)0, (short)_buffer.Length);
var inboundMessage = new RawMessage(_buffer.Length);
if (position == 0)
{
inboundMessage.Header(inboundHeader);
}
inboundMessage.Append(_buffer.ToArray(), position, bytesToAppend);
inboundMessage.CopyBytesTo(_builder.WorkBuffer());
}
public static RawMessage ToRawMessage(this short sendingNodeId, Stream buffer)
{
buffer.Flip();
var message = new RawMessage(buffer.Length);
message.Put(buffer, false);
buffer.SetLength(0); // clear
var header = new RawMessageHeader(sendingNodeId, (short)0, (int)message.Length);
message.Header(header);
return(message);
}
public static MemoryStream BytesFrom(string text)
{
var message = new RawMessage(Converters.TextToBytes(text));
var header = RawMessageHeader.From(1, 0, message.Length);
message.Header(header);
var buffer = new MemoryStream(4000);
message.CopyBytesTo(buffer);
buffer.Flip();
return(buffer);
}
public void TestHeaderFrom()
{
var buffer = new MemoryStream(1000);
var header = RawMessageHeader.From(1, 0, 100);
var message = new RawMessage(100);
header.CopyBytesTo(buffer);
buffer.Flip();
message.HeaderFrom(buffer);
buffer.Flip();
var convertedHeader = RawMessageHeader.From(buffer);
Assert.Equal(header, convertedHeader);
}
public void TestKnownSizeWithAppend()
{
var buffer = new MemoryStream(1000);
var node1 = NextNodeWith(1);
var join = new Join(node1);
MessageConverters.MessageToBytes(join, buffer);
buffer.Flip();
var messageSize = buffer.Length;
var message = new RawMessage(messageSize); // known size
message.Header(RawMessageHeader.From(node1.Id.Value, 0, messageSize));
message.Append(buffer.ToArray(), 0, messageSize);
Assert.Equal(node1.Id.Value, message.Header().NodeId);
Assert.Equal(messageSize, message.Header().Length);
Assert.Equal(join, OperationalMessage.MessageFrom(message.AsTextMessage()));
}
public void TestFromBytesWithLengthAndRequiredMessageLength()
{
var buffer = new MemoryStream(1000);
var node1 = NextNodeWith(1);
var join = new Join(node1);
MessageConverters.MessageToBytes(join, buffer);
buffer.Flip();
var messageSize = buffer.Length;
var messageBytes = new byte[messageSize];
Array.Copy(buffer.ToArray(), 0, messageBytes, 0, messageSize);
var message = new RawMessage(messageBytes);
message.Header(RawMessageHeader.From(node1.Id.Value, 0, message.Length));
Assert.Equal(node1.Id.Value, message.Header().NodeId);
Assert.Equal(message.Length, message.Header().Length);
Assert.Equal(message.Length, message.RequiredMessageLength);
Assert.Equal(join, OperationalMessage.MessageFrom(message.AsTextMessage()));
}
public void TestCopyBytesTo()
{
var buffer = new MemoryStream(1000);
var node1 = NextNodeWith(1);
var join = new Join(node1);
MessageConverters.MessageToBytes(join, buffer);
buffer.Flip();
var messageSize = buffer.Length;
var messageBytes = new byte[messageSize];
Array.Copy(buffer.ToArray(), 0, messageBytes, 0, messageSize);
var message = new RawMessage(messageBytes);
message.Header(RawMessageHeader.From(node1.Id.Value, 0, message.Length));
buffer.Clear();
message.CopyBytesTo(buffer); // copyBytesTo
var text = buffer.ToArray().BytesToText(RawMessageHeader.Bytes, (int)message.Length);
Assert.True(OperationalMessage.MessageFrom(text).IsJoin);
}
public void TestCopyBytesTo()
{
var buffer = new MemoryStream(1000);
var text = "JOIN\nid=1 nm=node1 op=localhost:35745 app=localhost:35746";
var node1 = Node.With(Id.Of(1), Name.Of("node1"), Host.Of("localhost"), 35745, 35746);
var bytes = Converters.TextToBytes(text);
buffer.Write(bytes, 0, bytes.Length);
buffer.Flip();
var messageSize = buffer.Length;
var messageBytes = new byte[messageSize];
Array.Copy(buffer.ToArray(), 0, messageBytes, 0, messageSize);
var message = new RawMessage(messageBytes);
message.Header(RawMessageHeader.From(node1.Id.Value, 0, message.Length));
Assert.Equal(text, message.AsTextMessage());
buffer.Clear();
message.CopyBytesTo(buffer); // copyBytesTo
var convertedText = buffer.ToArray().BytesToText(RawMessageHeader.Bytes, (int)message.Length);
Assert.Equal(text, convertedText);
}
public RawMessage(byte[] bytes)
{
_bytes = bytes;
_header = new RawMessageHeader();
_index = bytes.Length;
}
public static RawMessageHeader From(Stream buffer)
{
var header = new RawMessageHeader();
return(header.Read(buffer));
}
public void Header(RawMessageHeader header) => _header = header;
public static RawMessage From(int nodeId, int type, int length) => new RawMessage(RawMessageHeader.From(nodeId, type, length), length);
public RawMessage(RawMessage copy) : this(copy.Length)
{
Append(copy._bytes, 0, copy.Length);
Header(RawMessageHeader.From(copy._header));
}
public static RawMessageHeader From(RawMessageHeader copy) => From(copy._nodeId, copy._type, copy._length);
public RawMessage(RawMessageHeader header, long maxMessageSize)
{
_bytes = new byte[maxMessageSize];
_header = header;
_index = 0;
}
