public override TPackageInfo Filter(ref SequenceReader <byte> reader)
{
if (!_foundHeader)
{
if (reader.Length < _headerSize)
{
return(null);
}
var header = reader.Sequence.Slice(0, _headerSize);
var bodyLength = GetBodyLengthFromHeader(header);
if (bodyLength < 0)
{
throw new ProtocolException("Failed to get body length from the package header.");
}
if (bodyLength == 0)
{
return(DecodePackage(header));
}
_foundHeader = true;
_totalSize = _headerSize + bodyLength;
}
var totalSize = _totalSize;
if (reader.Length < totalSize)
{
return(null);
}
var pack = reader.Sequence.Slice(0, totalSize);
try
{
return(DecodePackage(pack));
}
finally
{
reader.Advance(totalSize);
}
}
public override bool Process(WebSocketPackage package, ref SequenceReader <byte> reader, out IPackagePartReader <WebSocketPackage> nextPartReader, out bool needMoreData)
{
if (reader.Length < 2)
{
nextPartReader = null;
needMoreData = true;
return(false);
}
needMoreData = false;
reader.TryRead(out byte firstByte);
package.OpCode = (OpCode)(firstByte & 0x0f);
package.OpCodeByte = firstByte;
reader.TryRead(out byte secondByte);
package.PayloadLength = secondByte & 0x7f;
package.HasMask = (secondByte & 0x80) == 0x80;
if (package.PayloadLength >= 126)
{
nextPartReader = ExtendedLenghtReader;
}
else
{
if (package.HasMask)
{
nextPartReader = MaskKeyReader;
}
else
{
// no body
if (package.PayloadLength == 0)
{
nextPartReader = null;
return(true);
}
nextPartReader = PayloadDataReader;
}
}
return(false);
}
public override bool Process(WebSocketPackage package, object filterContext, ref SequenceReader <byte> reader, out IPackagePartReader <WebSocketPackage> nextPartReader, out bool needMoreData)
{
int required;
if (package.PayloadLength == 126)
{
required = 2;
}
else
{
required = 8;
}
if (reader.Remaining < required)
{
nextPartReader = null;
needMoreData = true;
return(false);
}
needMoreData = false;
if (required == 2)
{
reader.TryReadBigEndian(out ushort len);
package.PayloadLength = len;
}
else // required == 8 (long)
{
reader.TryReadBigEndian(out long len);
package.PayloadLength = len;
}
if (package.HasMask)
{
nextPartReader = MaskKeyReader;
}
else
{
nextPartReader = PayloadDataReader;
}
return(false);
}
public RemoteProcedureCallMetadata(ReadOnlySequence <byte> metadata)
{
var reader = new SequenceReader <byte>(metadata);
if (!reader.TryReadBigEndian(out UInt16 version))
{
throw new ArgumentOutOfRangeException(nameof(version), $"Invalid RPC Metadata.");
}
if (version != VERSION)
{
throw new ArgumentOutOfRangeException(nameof(version), $"Unsupported RPC Version {version}, expected {VERSION}.");
}
if (!reader.TryReadBigEndian(out UInt16 servicelength))
{
throw new ArgumentOutOfRangeException(nameof(servicelength), $"Invalid RPC Metadata.");
}
if (reader.TryRead(out string service, servicelength))
{
Service = service;
}
else
{
throw new ArgumentOutOfRangeException(nameof(service), $"Invalid RPC Metadata.");
}
if (!reader.TryReadBigEndian(out UInt16 methodlength))
{
throw new ArgumentOutOfRangeException(nameof(methodlength), $"Invalid RPC Metadata.");
}
if (reader.TryRead(out string method, methodlength))
{
Method = method;
}
else
{
throw new ArgumentOutOfRangeException(nameof(method), $"Invalid RPC Metadata.");
}
if (!reader.TryReadBigEndian(out UInt16 tracinglength))
{
throw new ArgumentOutOfRangeException(nameof(tracinglength), $"Invalid RPC Metadata.");
}
Tracing = reader.Sequence.Slice(reader.Position, tracinglength);
reader.Advance(tracinglength);
Metadata = reader.Sequence.Slice(reader.Position, reader.Remaining);
}
public void TryReadToSpan_Sequence(bool advancePastDelimiter)
{
ReadOnlySequence <byte> bytes = SequenceFactory.Create(new byte[][] {
new byte[] { 0, 0 },
new byte[] { 1, 1, 2, 2 },
new byte[] { },
new byte[] { 3, 3, 4, 4, 5, 5, 6, 6 }
});
SequenceReader <byte> baseReader = new SequenceReader <byte>(bytes);
for (byte i = 0; i < bytes.Length / 2 - 1; i++)
{
byte[] expected = new byte[i * 2 + 1];
for (int j = 0; j < expected.Length - 1; j++)
{
expected[j] = (byte)(j / 2);
}
expected[i * 2] = i;
ReadOnlySpan <byte> searchFor = new byte[] { i, (byte)(i + 1) };
SequenceReader <byte> copy = baseReader;
Assert.True(copy.TryReadTo(out ReadOnlySpan <byte> sp, searchFor, advancePastDelimiter));
Assert.True(sp.SequenceEqual(expected));
copy = baseReader;
Assert.True(copy.TryReadTo(out ReadOnlySequence <byte> seq, searchFor, advancePastDelimiter));
Assert.True(seq.ToArray().AsSpan().SequenceEqual(expected));
}
bytes = SequenceFactory.Create(new byte[][] {
new byte[] { 47, 42, 66, 32, 42, 32, 66, 42, 47 } // /*b * b*/
});
baseReader = new SequenceReader <byte>(bytes);
SequenceReader <byte> copyReader = baseReader;
Assert.True(copyReader.TryReadTo(out ReadOnlySpan <byte> span, new byte[] { 42, 47 }, advancePastDelimiter)); // */
Assert.True(span.SequenceEqual(new byte[] { 47, 42, 66, 32, 42, 32, 66 }));
copyReader = baseReader;
Assert.True(copyReader.TryReadTo(out ReadOnlySequence <byte> sequence, new byte[] { 42, 47 }, advancePastDelimiter)); // */
Assert.True(sequence.ToArray().AsSpan().SequenceEqual(new byte[] { 47, 42, 66, 32, 42, 32, 66 }));
}
public override TPackageInfo Filter(ref SequenceReader <byte> reader)
{
if (!_foundHeader)
{
if (reader.Length < _headerSize)
{
return(null);
}
var header = reader.Sequence.Slice(0, _headerSize);
var bodyLength = GetBodyLengthFromHeader(header);
if (bodyLength < 0)
{
throw new ProtocolException("Failed to get body length from the package header.");
}
if (bodyLength == 0)
{
return(DecodePackage(header));
}
_foundHeader = true;
_totalSize = _headerSize + bodyLength;
return(Filter(ref reader));
}
var totalSize = _totalSize;
var sequence = reader.Sequence;
if (reader.Length > totalSize)
{
sequence = sequence.Slice(0, totalSize);
}
var package = DecodePackage(sequence);
// mark the data consumed
reader.Advance(totalSize);
return(package);
}
public HttpRequestInfo Filter(ref SequenceReader <byte> reader)
{
lock (lockObj)
{
try
{
if (_httpRequestInfo == null || (_httpRequestInfo != null && _httpRequestInfo.FilterStatus == FilterStatus.Completed))
{
raw = new List <byte>();
_httpRequestInfo = new HttpRequestInfo();
}
raw.AddRange(reader.Sequence.ToArray());
LoadRequestLine(ref reader);
LoadRequestHeader(ref reader);
LoadRequestBody(ref reader);
if (_httpRequestInfo.FilterStatus != FilterStatus.Completed)
{
return(null);
}
_httpRequestInfo.Raw = raw.ToArray();
_httpRequestInfo.BaseUrl = _httpRequestInfo.Headers["Host"];
_httpRequestInfo.Success = true;
_httpRequestInfo.Message = "HTTP请求解析成功";
return(_httpRequestInfo);
}
catch (Exception ex)
{
LogHelper.Error($"http解析异常：{ex}");
_httpRequestInfo.FilterStatus = FilterStatus.Completed;
return(new HttpRequestInfo()
{
Success = false, Message = ex.Message
});
}
finally
{
Reset();
}
}
}
public object ReadValue(ref SequenceReader <byte> reader, int meta)
{
/*
* (in big endian)
* 1 bit sign (1= non-negative, 0= negative)
* 17 bits year*13+month (year 0-9999, month 0-12)
* 5 bits day (0-31)
* 5 bits hour (0-23)
* 6 bits minute (0-59)
* 6 bits second (0-59)
* (5 bytes in total)
+ fractional-seconds storage (size depends on meta)
*/
reader.TryReadBigEndian(out int totalValue0);
reader.TryRead(out byte totalValue1);
var totalValue = (long)totalValue0 * 256 + totalValue1;
if (totalValue == 0)
{
return(null);
}
var seconds = (int)(totalValue & 0x3F);
totalValue = totalValue >> 6;
var minutes = (int)(totalValue & 0x3F);
totalValue = totalValue >> 6;
var hours = (int)(totalValue & 0x1F);
totalValue = totalValue >> 5;
var days = (int)(totalValue & 0x1F);
totalValue = totalValue >> 5;
var yearMonths = (int)(totalValue & 0x01FFFF);
var year = yearMonths / 13;
var month = yearMonths % 13;
var fsp = ReadFractionalSeconds(ref reader, meta);
return(new DateTime(year, month, days, hours, minutes, seconds, fsp / 1000));
}
private bool TryParseRecord(ref SequenceReader <byte> reader, long baseOffset, out RecordBatch.Record message)
{
message = default;
if (!reader.TryReadVarint64(out long length))
{
return(false);
}
if (!reader.TryReadByte(out var attributes))
{
return(false);
}
if (!reader.TryReadVarint64(out long timestampDelta))
{
return(false);
}
if (!reader.TryReadVarint64(out long offsetDelta))
{
return(false);
}
if (!reader.TryReadCompactBytes(out var key))
{
return(false);
}
if (!reader.TryReadCompactBytes(out var value))
{
return(false);
}
if (!reader.TryReadArray <RecordBatch.Record.Header>(TryParseRecordHeader, out var headers, useVarIntLength: true))
{
return(false);
}
message = new RecordBatch.Record
{
Attributes = attributes,
TimeStampDelta = timestampDelta,
OffsetDelta = offsetDelta,
Offset = baseOffset + offsetDelta,
Key = key.ToArray(),
Value = value.ToArray(),
Headers = headers
};
return(true);
}
public override bool Process(WebSocketPackage package, ref SequenceReader <byte> reader, out IDataFramePartReader nextPartReader, out bool needMoreData)
{
int required = 4;
if (reader.Remaining < required)
{
nextPartReader = null;
needMoreData = true;
return(false);
}
needMoreData = false;
package.MaskKey = reader.Sequence.Slice(reader.Consumed, 4).ToArray();
reader.Advance(4);
nextPartReader = PayloadDataReader;
return(false);
}
private int[] ReadColumnMetadata(ref SequenceReader <byte> reader, byte[] columnTypes)
{
var columnMetadata = new int[columnTypes.Length];
for (int i = 0; i < columnTypes.Length; i++)
{
switch ((ColumnType)columnTypes[i])
{
case ColumnType.FLOAT:
case ColumnType.DOUBLE:
case ColumnType.BLOB:
case ColumnType.JSON:
case ColumnType.GEOMETRY:
columnMetadata[i] = (int)reader.ReadLong(1);
break;
case ColumnType.BIT:
case ColumnType.VARCHAR:
case ColumnType.NEWDECIMAL:
columnMetadata[i] = (int)reader.ReadLong(2);
break;
case ColumnType.SET:
case ColumnType.ENUM:
case ColumnType.STRING:
reader.TryReadBigEndian(out short value);
columnMetadata[i] = (int)value;
break;
case ColumnType.TIME_V2:
case ColumnType.DATETIME_V2:
case ColumnType.TIMESTAMP_V2:
columnMetadata[i] = (int)reader.ReadLong(1);
break;
default:
columnMetadata[i] = 0;
break;
}
}
return(columnMetadata);
}
private List <string[]> ReadTypeValues(ref SequenceReader <byte> reader)
{
var result = new List <string[]>();
while (reader.Remaining > 0)
{
int valuesCount = (int)reader.ReadLengthEncodedInteger();
var typeValues = new string[valuesCount];
for (var i = 0; i < valuesCount; i++)
{
typeValues[i] = reader.ReadLengthEncodedString();
}
result.Add(typeValues);
}
return(result);
}
public void DifferentFormsWorkTogether()
{
// InOriginForm
var rawTarget = "/a%20path%20with%20spaces?q=123&w=xyzw12";
var path = "/a path with spaces";
var query = "?q=123&w=xyzw12";
Http1Connection.Reset();
var ros = new ReadOnlySequence <byte>(Encoding.ASCII.GetBytes($"POST {rawTarget} HTTP/1.1\r\n"));
var reader = new SequenceReader <byte>(ros);
Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
// Equal the inputs.
Assert.Equal(rawTarget, Http1Connection.RawTarget);
Assert.Equal(path, Http1Connection.Path);
Assert.Equal(query, Http1Connection.QueryString);
// But not the same as the inputs.
Assert.NotSame(rawTarget, Http1Connection.RawTarget);
Assert.NotSame(path, Http1Connection.Path);
Assert.NotSame(query, Http1Connection.QueryString);
InAuthorityForm();
InOriginForm();
InAbsoluteForm();
InOriginForm();
InAsteriskForm();
InAuthorityForm();
InAsteriskForm();
InAbsoluteForm();
InAuthorityForm();
InAbsoluteForm();
InAsteriskForm();
InAbsoluteForm();
InAuthorityForm();
}
private void ParseData()
{
if (!_parser.ParseRequestLine(new Adapter(this), _buffer, out var consumed, out var examined))
{
ErrorUtilities.ThrowInvalidRequestHeaders();
}
_buffer = _buffer.Slice(consumed, _buffer.End);
var reader = new SequenceReader <byte>(_buffer);
if (!_parser.ParseHeaders(new Adapter(this), ref reader))
{
ErrorUtilities.ThrowInvalidRequestHeaders();
}
Connection.EnsureHostHeaderExists();
Connection.Reset();
}
private void VerifyRawHeaders(string rawHeaders, IEnumerable <string> expectedHeaderNames, IEnumerable <string> expectedHeaderValues)
{
Assert.True(expectedHeaderNames.Count() == expectedHeaderValues.Count(), $"{nameof(expectedHeaderNames)} and {nameof(expectedHeaderValues)} sizes must match");
var parser = CreateParser(_nullTrace);
var buffer = new ReadOnlySequence <byte>(Encoding.ASCII.GetBytes(rawHeaders));
var requestHandler = new RequestHandler();
var reader = new SequenceReader <byte>(buffer);
Assert.True(parser.ParseHeaders(requestHandler, ref reader));
var parsedHeaders = requestHandler.Headers.ToArray();
Assert.Equal(expectedHeaderNames.Count(), parsedHeaders.Length);
Assert.Equal(expectedHeaderNames, parsedHeaders.Select(t => t.Key));
Assert.Equal(expectedHeaderValues, parsedHeaders.Select(t => t.Value));
Assert.True(buffer.Slice(reader.Position).IsEmpty);
}
private static void ParseLine(ref ReadOnlySequence <byte> lineBuffer, Span <string?> fieldResult, ref int index, bool isEol, bool isHeader = false, byte fieldDelimiter = 44)
{
var sequenceReader = new SequenceReader <byte>(lineBuffer);
char[] fieldBuffer = ArrayPool <char> .Shared.Rent(64);
do
{
var fieldSpan = CsvParser.ParseField(ref sequenceReader, fieldDelimiter, isEol, fieldBuffer.AsSpan());
if (fieldSpan.Length == 1 && fieldSpan[0] == Char.MinValue)
{
if (!isHeader && sequenceReader.End)
{
index++;
}
break;
}
if (isHeader)
{
Span <char> charsResult = stackalloc char[fieldSpan.Length];
try
{
fieldResult[index++] = fieldSpan == String.Empty ? null : new string(FormatField(fieldSpan, charsResult));
}
catch (ArgumentNullException)
{
ArrayPool <char> .Shared.Return(fieldBuffer);
throw;
}
}
else
{
fieldResult[index++] = fieldSpan.IsEmpty ? null : new string(fieldSpan);
}
} while (!sequenceReader.End);
ArrayPool <char> .Shared.Return(fieldBuffer);
lineBuffer = lineBuffer.Slice(sequenceReader.Position);
}
private SequencePosition GetFrameLength(ReadOnlySequence <byte> buffer, out int length)
{
if (buffer.Length < 4)
{
throw new ArgumentException();
}
var seqReader = new SequenceReader <byte>(buffer);
if (seqReader.TryReadLittleEndian(out length))
{
seqReader.Advance(4);
return(seqReader.Position);
}
else
{
throw new ArgumentException();
}
}
public void Filter(ref SequenceReader <byte> reader)
{
if (!_foundHeader)
{
if (reader.Length < _headerSize)
{
//return null;
Console.WriteLine("");
}
_foundHeader = true;
var header = reader.Sequence.Slice(0, _headerSize);
var bodyLength = GetBodyLengthFromHeader(header);
if (bodyLength < 0)
{
throw new Exception("Failed to get body length from the package header.");
}
else if (bodyLength == 0)
{
reader.Advance(_headerSize);
// return DecodePackage(header);
}
else
{
_totalSize = _headerSize + bodyLength;
}
}
var totalSize = _totalSize;
if (reader.Length > totalSize)
{
reader.Advance(totalSize);
// return DecodePackage(reader.Sequence.Slice(0, totalSize));
}
else if (reader.Length == totalSize)
{
reader.Advance(totalSize);
//return DecodePackage(reader.Sequence);
}
// return null;
}
public override VersionMessage Deserialize(ReadOnlySpan <byte> data)
{
var reader = new SequenceReader <byte>(new ReadOnlySequence <byte>(data.ToArray()));
var message = new VersionMessage();
message.Version = reader.ReadInt();
message.Services = reader.ReadULong();
message.Timestamp = DateTimeOffset.FromUnixTimeSeconds(reader.ReadLong());
message.ReceiverAddress = reader.ReadNetworkAddress();
// from here down, if version >= 106
message.SenderAddress = reader.ReadNetworkAddress();
message.Nonce = reader.ReadULong();
message.UserAgent = reader.ReadVarString();
message.StartHeight = reader.ReadInt();
// from here down, if version >= 70001
message.Relay = reader.ReadBool();
return(message);
}
private static long ProcessLine(ref ReadOnlySequence <byte> buffer)
{
long str = 0;
if (buffer.IsSingleSegment)
{
var span = buffer.FirstSpan;
int consumed;
while (span.Length > 0)
{
var newLine = span.IndexOf((byte)'\n');
if (newLine == -1)
{
break;
}
var line = span.Slice(0, newLine);
str += ParseRow(line);
consumed = line.Length + 1;
span = span.Slice(consumed);
buffer = buffer.Slice(consumed);
}
}
else
{
var sequenceReader = new SequenceReader <byte>(buffer);
while (!sequenceReader.End)
{
while (sequenceReader.TryReadTo(out ReadOnlySpan <byte> line, (byte)'\n'))
{
str += ParseRow(line);
}
buffer = buffer.Slice(sequenceReader.Position);
sequenceReader.Advance(buffer.Length);
}
}
return(str);
}
public LogEvent Decode(ReadOnlySequence <byte> buffer, object context)
{
var reader = new SequenceReader <byte>(buffer);
reader.Advance(4); // 3 + 1
// ok byte
reader.TryRead(out byte ok);
if (ok == 0xFF)
{
var errorLogEvent = new ErrorEvent();
errorLogEvent.DecodeBody(ref reader, context);
return(errorLogEvent);
}
reader.TryReadLittleEndian(out int seconds);
var timestamp = LogEvent.GetTimestapmFromUnixEpoch(seconds);
reader.TryRead(out byte eventTypeValue);
var eventType = (LogEventType)eventTypeValue;
var log = CreateLogEvent(eventType, context);
log.Timestamp = timestamp;
log.EventType = eventType;
reader.TryReadLittleEndian(out int serverID);
log.ServerID = serverID;
reader.TryReadLittleEndian(out int eventSize);
log.EventSize = eventSize;
reader.TryReadLittleEndian(out int position);
log.Position = position;
reader.TryReadLittleEndian(out short flags);
log.Flags = (LogEventFlag)flags;
log.DecodeBody(ref reader, context);
return(log);
}
public override bool TryParseFrame(SequenceReader <byte> reader, out BasicFrame frame, out SequencePosition consumedTo)
{
if (reader.TryReadLittleEndian(out int messageId) &&
reader.TryReadLittleEndian(out int length) &&
reader.Remaining >= length)
{
frame = new BasicFrame
{
MessageId = messageId
};
var payload = reader.Sequence.Slice(reader.Position, length);
frame.Payload = payload.Lease();
consumedTo = payload.End;
return(true);
}
frame = default;
consumedTo = default;
return(false);
}
public override TPackageInfo Filter(ref SequenceReader <byte> reader)
{
var terminator = _terminator;
var terminatorSpan = terminator.Span;
if (!reader.TryReadTo(out ReadOnlySequence <byte> pack, terminatorSpan, advancePastDelimiter: false))
{
return(null);
}
try
{
return(DecodePackage(pack));
}
finally
{
reader.Advance(terminator.Length);
}
}
protected string ReadString(ref SequenceReader <byte> reader, out long length)
{
if (reader.TryReadTo(out ReadOnlySequence <byte> seq, 0x00, false))
{
length = seq.Length + 1;
var result = seq.GetString(Encoding.UTF8);
reader.Advance(1);
return(result);
}
else
{
length = reader.Remaining;
seq = reader.Sequence;
seq = seq.Slice(reader.Consumed);
var result = seq.GetString(Encoding.UTF8);
reader.Advance(length);
return(result);
}
}
public override TPackageInfo Filter(ref SequenceReader <byte> reader)
{
var terminator = new ReadOnlySpan <byte>(_terminator);
if (!reader.TryReadToAny(out ReadOnlySpan <byte> pack, terminator, advancePastDelimiter: false))
{
return(null);
}
for (var i = 0; i < _terminator.Length - 1; i++)
{
if (!reader.IsNext(_terminator, advancePast: true))
{
return(null);
}
}
return(ResolvePackage(pack));
}
private static bool TryRead32BitLittleEndian <T>(ReadOnlySequence <byte> source, out T value)
where T : unmanaged
{
Debug.Assert(sizeof(T) == 4);
var reader = new SequenceReader <byte>(source);
if (reader.TryReadLittleEndian(out int intValue))
{
T *pValue = (T *)&intValue;
value = *pValue;
return(true);
}
else
{
value = default;
return(false);
}
}
private bool TryParseMember(ref SequenceReader <byte> reader, out JoinGroupResponse.Member member)
{
member = default;
if (!reader.TryReadString(out var memberId))
{
return(false);
}
if (!reader.TryReadString(out var groupInstanceId))
{
return(false);
}
if (!reader.TryReadBytes(out var metadata))
{
return(false);
}
member = new JoinGroupResponse.Member(memberId, groupInstanceId, metadata.ToArray());
return(true);
}
public WebSocketPackage Filter(ref SequenceReader <byte> reader)
{
var package = _currentPackage;
if (package == null)
{
_currentPackage = package = new WebSocketPackage();
_currentPartReader = DataFramePartReader.NewReader;
}
if (!_currentPartReader.Process(package, ref reader, out IDataFramePartReader nextPartReader))
{
_currentPartReader = nextPartReader;
return(null);
}
Reset();
return(package);
}
public void PastEmptySegments()
{
ReadOnlySequence <byte> bytes = SequenceFactory.Create(new byte[][] {
new byte[] { 0 },
new byte[] { },
new byte[] { },
new byte[] { }
});
SequenceReader <byte> reader = new SequenceReader <byte>(bytes);
reader.Advance(1);
Assert.Equal(0, reader.CurrentSpanIndex);
Assert.Equal(0, reader.CurrentSpan.Length);
Assert.False(reader.TryPeek(out byte value));
ReadOnlySequence <byte> sequence = reader.Sequence.Slice(reader.Position);
Assert.Equal(0, sequence.Length);
}
private static bool TryRead64BitBigEndian <T>(ReadOnlySequence <byte> source, out T value)
where T : unmanaged
{
Debug.Assert(sizeof(T) == 8);
var reader = new SequenceReader <byte>(source);
if (reader.TryReadBigEndian(out long longValue))
{
T *pValue = (T *)&longValue;
value = *pValue;
return(true);
}
else
{
value = default;
return(false);
}
}
