protected override void Write(Span <byte> bytesToWrite)
{
_byteBuffer.EnsureWritable(bytesToWrite.Length, true);
bytesToWrite.CopyTo(_byteBuffer.Array.AsSpan(_byteBuffer.ArrayOffset + _byteBuffer.WriterIndex, bytesToWrite.Length));
int newWriterIndex = _byteBuffer.WriterIndex + bytesToWrite.Length;
_byteBuffer.SetWriterIndex(newWriterIndex);
}
public override void Write(Span <byte> bytesToWrite)
{
_buffer.EnsureWritable(bytesToWrite.Length, true);
Span <byte> target =
_buffer.Array.AsSpan(_buffer.ArrayOffset + _buffer.WriterIndex, bytesToWrite.Length);
bytesToWrite.CopyTo(target);
int newWriterIndex = _buffer.WriterIndex + bytesToWrite.Length;
_buffer.SetWriterIndex(newWriterIndex);
}
public void Serialize(IByteBuffer byteBuffer, StatusMessage message)
{
int forkIdContentLength = 0;
if (message.ForkId.HasValue)
{
ForkId forkId = message.ForkId.Value;
forkIdContentLength = Rlp.LengthOf(forkId.ForkHash) + Rlp.LengthOf(forkId.Next);
}
NettyRlpStream rlpStream = new(byteBuffer);
int totalLength = GetLength(message, out int contentLength);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.ProtocolVersion);
rlpStream.Encode(message.ChainId);
rlpStream.Encode(message.TotalDifficulty);
rlpStream.Encode(message.BestHash);
rlpStream.Encode(message.GenesisHash);
if (message.ForkId != null)
{
ForkId forkId = message.ForkId.Value;
rlpStream.StartSequence(forkIdContentLength);
rlpStream.Encode(forkId.ForkHash);
rlpStream.Encode(forkId.Next);
}
}
public void Serialize(IByteBuffer byteBuffer, NewBlockHashesMessage message)
{
NettyRlpStream nettyRlpStream = new(byteBuffer);
int contentLength = 0;
for (int i = 0; i < message.BlockHashes.Length; i++)
{
int miniContentLength = Rlp.LengthOf(message.BlockHashes[i].Item1);
miniContentLength += Rlp.LengthOf(message.BlockHashes[i].Item2);
contentLength += Rlp.GetSequenceRlpLength(miniContentLength);
}
int totalLength = Rlp.LengthOfSequence(contentLength);
byteBuffer.EnsureWritable(totalLength, true);
nettyRlpStream.StartSequence(contentLength);
for (int i = 0; i < message.BlockHashes.Length; i++)
{
int miniContentLength = Rlp.LengthOf(message.BlockHashes[i].Item1);
miniContentLength += Rlp.LengthOf(message.BlockHashes[i].Item2);
nettyRlpStream.StartSequence(miniContentLength);
nettyRlpStream.Encode(message.BlockHashes[i].Item1);
nettyRlpStream.Encode(message.BlockHashes[i].Item2);
}
}
protected override void Encode(IChannelHandlerContext context, IMessage message, IByteBuffer output)
{
int iCode = PtlCodeHelper.Instance.GetCode(message.GetType());
if (iCode <= 0)
{
return;
}
int bodyLength = message.CalculateSize();
if (bodyLength == 0)
{
return;
}
int headerLength = sizeof(int) * 2;
int totalLength = bodyLength + headerLength;
output.EnsureWritable(totalLength);
output.WriteInt(totalLength); //长度
output.WriteInt(iCode); //协议号
var buffer = output.GetIoBuffer(output.WriterIndex, bodyLength);
using (MemoryStream memStream = new MemoryStream(buffer.Array, buffer.Offset, buffer.Count))
{
message.WriteTo(memStream);
output.SetWriterIndex(output.WriterIndex + (int)memStream.Length);
}
}
/// <summary>
/// Allocate or expand the decompression buffer, without exceeding the maximum allocation.
/// Calls <see cref="DecompressionBufferExhausted(IByteBuffer)"/> if the buffer is full and cannot be expanded further.
/// </summary>
/// <param name="ctx"></param>
/// <param name="buffer"></param>
/// <param name="preferredSize"></param>
/// <returns></returns>
protected IByteBuffer PrepareDecompressBuffer(IChannelHandlerContext ctx, IByteBuffer buffer, int preferredSize)
{
if (buffer is null)
{
if (0u >= (uint)_maxAllocation)
{
return(ctx.Allocator.HeapBuffer(preferredSize));
}
return(ctx.Allocator.HeapBuffer(Math.Min(preferredSize, _maxAllocation), _maxAllocation));
}
// this always expands the buffer if possible, even if the expansion is less than preferredSize
// we throw the exception only if the buffer could not be expanded at all
// this means that one final attempt to deserialize will always be made with the buffer at maxAllocation
if (buffer.EnsureWritable(preferredSize, true) == 1)
{
// buffer must be consumed so subclasses don't add it to output
// we therefore duplicate it when calling decompressionBufferExhausted() to guarantee non-interference
// but wait until after to consume it so the subclass can tell how much output is really in the buffer
DecompressionBufferExhausted(buffer.Duplicate());
_ = buffer.SkipBytes(buffer.ReadableBytes);
CThrowHelper.ThrowDecompressionException_Decompression_buffer_has_reached_maximum_size(buffer.MaxCapacity);
}
return(buffer);
}
public void Serialize(IByteBuffer byteBuffer, ContractCodesMessage message)
{
int innerLength = 0;
for (int i = 0; i < message.Codes.Length; i++)
{
innerLength += Rlp.LengthOf(message.Codes[i]);
}
int contentLength =
Rlp.LengthOf(message.RequestId) +
Rlp.LengthOf(message.BufferValue) +
Rlp.GetSequenceRlpLength(innerLength);
int totalLength = Rlp.GetSequenceRlpLength(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.Encode(message.BufferValue);
rlpStream.StartSequence(innerLength);
for (int i = 0; i < message.Codes.Length; i++)
{
rlpStream.Encode(message.Codes[i]);
}
}
public void Serialize(IByteBuffer byteBuffer, GetContractCodesMessage message)
{
// note: If there are any changes to how a hash is encoded, this will break (compression?)
// calling LengthOf for each hash would be more resistant to future changes, if we think there will be any
int requestLength = Rlp.LengthOf(Keccak.OfAnEmptyString) * 2;
int allRequestsLength = Rlp.GetSequenceRlpLength(requestLength) * message.Requests.Length;
int contentLength =
Rlp.LengthOf(message.RequestId) +
Rlp.GetSequenceRlpLength(allRequestsLength);
int totalLength = Rlp.GetSequenceRlpLength(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.StartSequence(allRequestsLength);
foreach (CodeRequest request in message.Requests)
{
rlpStream.StartSequence(requestLength);
rlpStream.Encode(request.BlockHash);
rlpStream.Encode(request.AccountKey);
}
}
public void Serialize(IByteBuffer byteBuffer, GetBlockHeadersMessage message)
{
int contentLength = message.StartingBlockHash == null?Rlp.LengthOf(message.StartingBlockNumber) : Rlp.LengthOf(message.StartingBlockHash);
contentLength += Rlp.LengthOf(message.MaxHeaders);
contentLength += Rlp.LengthOf(message.Skip);
contentLength += Rlp.LengthOf(message.Reverse);
int totalLength = Rlp.GetSequenceRlpLength(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength, true);
rlpStream.StartSequence(contentLength);
if (message.StartingBlockHash == null)
{
rlpStream.Encode(message.StartingBlockNumber);
}
else
{
rlpStream.Encode(message.StartingBlockHash);
}
rlpStream.Encode(message.MaxHeaders);
rlpStream.Encode(message.Skip);
rlpStream.Encode(message.Reverse);
}
public void Serialize(IByteBuffer byteBuffer, BlockWitnessHashesMessage message)
{
NettyRlpStream nettyRlpStream = new NettyRlpStream(byteBuffer);
int hashesContentLength = message.Hashes?.Length * Rlp.LengthOfKeccakRlp ?? 0;
int contentLength = Rlp.LengthOfSequence(hashesContentLength);
contentLength += Rlp.LengthOf(message.RequestId);
int totalLength = Rlp.LengthOfSequence(contentLength);
byteBuffer.EnsureWritable(totalLength, true);
nettyRlpStream.StartSequence(contentLength);
nettyRlpStream.Encode(message.RequestId);
if (message.Hashes == null)
{
nettyRlpStream.EncodeNullObject();
}
else
{
nettyRlpStream.StartSequence(hashesContentLength);
foreach (Keccak keccak in message.Hashes)
{
nettyRlpStream.Encode(keccak);
}
}
}
public void Serialize(IByteBuffer byteBuffer, GetHelperTrieProofsMessage message)
{
int innerLength = 0;
foreach (var request in message.Requests)
{
innerLength += Rlp.GetSequenceRlpLength(GetRequestLength(request));
}
int contentLength = Rlp.LengthOf(message.RequestId) +
Rlp.GetSequenceRlpLength(innerLength);
int totalLength = Rlp.GetSequenceRlpLength(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.StartSequence(innerLength);
foreach (var request in message.Requests)
{
rlpStream.StartSequence(GetRequestLength(request));
rlpStream.Encode((int)request.SubType);
rlpStream.Encode(request.SectionIndex);
rlpStream.Encode(request.Key);
rlpStream.Encode(request.FromLevel);
rlpStream.Encode(request.AuxiliaryData);
}
}
public void EnsureWritableWithNotEnoughSpaceShouldThrow()
{
IByteBuffer buf = this.NewBuffer(1, 10);
Assert.Throws <IndexOutOfRangeException>(() => buf.EnsureWritable(11));
buf.Release();
}
public void Serialize(IByteBuffer byteBuffer, GetTrieNodesMessage message)
{
(int contentLength, int allPathsLength, int[] pathsLengths) = CalculateLengths(message);
byteBuffer.EnsureWritable(Rlp.LengthOfSequence(contentLength), true);
NettyRlpStream stream = new (byteBuffer);
stream.StartSequence(contentLength);
stream.Encode(message.RequestId);
stream.Encode(message.RootHash);
if (message.Paths == null || message.Paths.Length == 0)
{
stream.EncodeNullObject();
}
else
{
stream.StartSequence(allPathsLength);
for (int i = 0; i < message.Paths.Length; i++)
{
PathGroup group = message.Paths[i];
stream.StartSequence(pathsLengths[i]);
for (int j = 0; j < group.Group.Length; j++)
{
stream.Encode(group.Group[j]);
}
}
}
stream.Encode(message.Bytes);
}
public void EnsureWritableWithEnoughSpaceShouldNotThrow()
{
IByteBuffer buf = this.NewBuffer(1, 10);
buf.EnsureWritable(3);
Assert.True(buf.WritableBytes >= 3);
buf.Release();
}
public void EnsureWritableWithNotEnoughSpaceShouldThrow()
{
IByteBuffer slice = this.NewBuffer(10);
IByteBuffer unwrapped = slice.Unwrap();
unwrapped.SetWriterIndex(unwrapped.WriterIndex + 5);
Assert.Throws <IndexOutOfRangeException>(() => slice.EnsureWritable(1));
slice.Release();
}
public void Serialize(IByteBuffer byteBuffer, GetBlockWitnessHashesMessage message)
{
NettyRlpStream nettyRlpStream = new(byteBuffer);
int totalLength = GetLength(message, out int contentLength);
byteBuffer.EnsureWritable(totalLength, true);
nettyRlpStream.StartSequence(contentLength);
nettyRlpStream.Encode(message.RequestId);
nettyRlpStream.Encode(message.BlockHash);
}
public void Serialize(IByteBuffer byteBuffer, TEth66Message message)
{
int length = GetLength(message, out int contentLength);
byteBuffer.EnsureWritable(length, true);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
_ethMessageSerializer.Serialize(byteBuffer, message.EthMessage);
}
protected NettyRlpStream GetRlpStreamAndStartSequence(IByteBuffer byteBuffer, T msg)
{
int totalLength = GetLength(msg, out int contentLength);
byteBuffer.EnsureWritable(totalLength, true);
NettyRlpStream stream = new (byteBuffer);
stream.StartSequence(contentLength);
return(stream);
}
public void Serialize(IByteBuffer byteBuffer, GetBlockBodiesMessage message)
{
int length = GetLength(message, out int contentLength);
byteBuffer.EnsureWritable(length, true);
NettyRlpStream nettyRlpStream = new(byteBuffer);
nettyRlpStream.StartSequence(contentLength);
for (int i = 0; i < message.BlockHashes.Count; i++)
{
nettyRlpStream.Encode(message.BlockHashes[i]);
}
}
public void Serialize(IByteBuffer byteBuffer, NodeDataMessage message)
{
int length = GetLength(message, out int contentLength);
byteBuffer.EnsureWritable(length, true);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
rlpStream.StartSequence(contentLength);
for (int i = 0; i < message.Data.Length; i++)
{
rlpStream.Encode(message.Data[i]);
}
}
public void Serialize(IByteBuffer byteBuffer, NewBlockMessage message)
{
int contentLength = _blockDecoder.GetLength(message.Block, RlpBehaviors.None) + Rlp.LengthOf(message.TotalDifficulty);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
int totalLength = Rlp.LengthOfSequence(contentLength);
byteBuffer.EnsureWritable(totalLength, true);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.Block);
rlpStream.Encode(message.TotalDifficulty);
}
public void Serialize(IByteBuffer byteBuffer, StorageRangeMessage message)
{
(int contentLength, int allSlotsLength, int[] accountSlotsLengths, int proofsLength) = CalculateLengths(message);
byteBuffer.EnsureWritable(Rlp.LengthOfSequence(contentLength), true);
NettyRlpStream stream = new(byteBuffer);
stream.StartSequence(contentLength);
stream.Encode(message.RequestId);
if (message.Slots == null || message.Slots.Length == 0)
{
stream.EncodeNullObject();
}
else
{
stream.StartSequence(allSlotsLength);
for (int i = 0; i < message.Slots.Length; i++)
{
stream.StartSequence(accountSlotsLengths[i]);
PathWithStorageSlot[] accountSlots = message.Slots[i];
for (int j = 0; j < accountSlots.Length; j++)
{
var slot = accountSlots[j];
int itemLength = Rlp.LengthOf(slot.Path) + Rlp.LengthOf(slot.SlotRlpValue);
stream.StartSequence(itemLength);
stream.Encode(slot.Path);
stream.Encode(slot.SlotRlpValue);
}
}
}
if (message.Proofs == null || message.Proofs.Length == 0)
{
stream.EncodeNullObject();
}
else
{
stream.StartSequence(proofsLength);
for (int i = 0; i < message.Proofs.Length; i++)
{
stream.Encode(message.Proofs[i]);
}
}
}
public void Serialize(IByteBuffer byteBuffer, AnnounceMessage message)
{
int length = GetLength(message, out int contentLength);
byteBuffer.EnsureWritable(length);
NettyRlpStream rlpStream = new(byteBuffer);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.HeadHash);
rlpStream.Encode(message.HeadBlockNo);
rlpStream.Encode(message.TotalDifficulty);
rlpStream.Encode(message.ReorgDepth);
rlpStream.Encode(Rlp.OfEmptySequence);
}
public void Serialize(IByteBuffer byteBuffer, ByteCodesMessage message)
{
(int contentLength, int codesLength) = GetLength(message);
byteBuffer.EnsureWritable(Rlp.LengthOfSequence(contentLength), true);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.StartSequence(codesLength);
for (int i = 0; i < message.Codes.Length; i++)
{
rlpStream.Encode(message.Codes[i]);
}
}
public void Serialize(IByteBuffer byteBuffer, GetBlockBodiesMessage message)
{
Eth.V62.GetBlockBodiesMessageSerializer ethSerializer = new Eth.V62.GetBlockBodiesMessageSerializer();
Rlp ethMessage = new Rlp(ethSerializer.Serialize(message.EthMessage));
int contentLength = Rlp.LengthOf(message.RequestId) + ethMessage.Length;
int totalLength = Rlp.GetSequenceRlpLength(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.Encode(ethMessage);
}
public void Serialize(IByteBuffer byteBuffer, GetReceiptsMessage message)
{
Eth.V63.Messages.GetReceiptsMessageSerializer ethSerializer = new();
Rlp ethMessage = new(ethSerializer.Serialize(message.EthMessage));
int contentLength = Rlp.LengthOf(message.RequestId) + ethMessage.Length;
int totalLength = Rlp.LengthOfSequence(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.Encode(ethMessage);
}
public void Serialize <T>(T message, IByteBuffer byteBuffer) where T : MessageBase
{
IMessageSerializer <T> serializer = GetSerializer <T>();
IZeroMessageSerializer <T> zeroSerializer = serializer as IZeroMessageSerializer <T>;
if (zeroSerializer != null)
{
zeroSerializer.Serialize(byteBuffer, message);
}
else
{
byte[] serialized = serializer.Serialize(message);
byteBuffer.EnsureWritable(serialized.Length, true);
byteBuffer.WriteBytes(serialized);
}
}
public void EnsureWritableWithEnoughSpaceShouldNotThrow()
{
IByteBuffer slice = this.NewBuffer(10);
IByteBuffer unwrapped = slice.Unwrap();
unwrapped.SetWriterIndex(unwrapped.WriterIndex + 5);
slice.SetWriterIndex(slice.ReaderIndex);
// Run ensureWritable and verify this doesn't change any indexes.
int originalWriterIndex = slice.WriterIndex;
int originalReadableBytes = slice.ReadableBytes;
slice.EnsureWritable(originalWriterIndex - slice.WriterIndex);
Assert.Equal(originalWriterIndex, slice.WriterIndex);
Assert.Equal(originalReadableBytes, slice.ReadableBytes);
slice.Release();
}
public void Serialize(IByteBuffer byteBuffer, ReceiptsMessage message)
{
Eth.V63.ReceiptsMessageSerializer ethSerializer = new Eth.V63.ReceiptsMessageSerializer(_specProvider);
Rlp ethMessage = new Rlp(ethSerializer.Serialize(message.EthMessage));
int contentLength = Rlp.LengthOf(message.RequestId) + Rlp.LengthOf(message.BufferValue) + ethMessage.Length;
int totalLength = Rlp.GetSequenceRlpLength(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.Encode(message.BufferValue);
rlpStream.Encode(ethMessage);
}
public static void MakeSpace(this IByteBuffer output, int length, string reason = null)
{
if (output.WritableBytes < length)
{
if (output.ReaderIndex == output.WriterIndex)
{
output.Clear();
}
else
{
output.DiscardReadBytes();
}
if (output.WritableBytes < length)
{
output.EnsureWritable(length, true);
}
}
}