public static void AssertRoundtrip <T>(MessageParser <T> parser, T message, Action <T> additionalAssert = null) where T : IMessage <T>
{
var bytes = message.ToByteArray();
// also serialize using IBufferWriter and check it leads to the same data
var bufferWriter = new TestArrayBufferWriter <byte>();
message.WriteTo(bufferWriter);
Assert.AreEqual(bytes, bufferWriter.WrittenSpan.ToArray(), "Both serialization approaches need to result in the same data.");
var parsedMsg = parser.ParseFrom(bytes);
Assert.AreEqual(message, parsedMsg);
additionalAssert?.Invoke(parsedMsg);
// Load content as single segment
parsedMsg = parser.ParseFrom(new ReadOnlySequence <byte>(bytes));
Assert.AreEqual(message, parsedMsg);
additionalAssert?.Invoke(parsedMsg);
// Load content as multiple segments
parsedMsg = parser.ParseFrom(ReadOnlySequenceFactory.CreateWithContent(bytes));
Assert.AreEqual(message, parsedMsg);
additionalAssert?.Invoke(parsedMsg);
// Load content as ReadOnlySpan
parsedMsg = parser.ParseFrom(new ReadOnlySpan <byte>(bytes));
Assert.AreEqual(message, parsedMsg);
additionalAssert?.Invoke(parsedMsg);
}
public static void AssertReadingMessageThrows <TMessage, TException>(MessageParser <TMessage> parser, byte[] bytes)
where TMessage : IMessage <TMessage>
where TException : Exception
{
Assert.Throws <TException>(() => parser.ParseFrom(bytes));
Assert.Throws <TException>(() => parser.ParseFrom(new ReadOnlySequence <byte>(bytes)));
}
public static void AssertReadingMessage(MessageParser parser, byte[] bytes, Action <IMessage> assert)
{
var parsedStream = parser.ParseFrom(bytes);
// Load content as single segment
var parsedBuffer = parser.ParseFrom(new ReadOnlySequence <byte>(bytes));
assert(parsedBuffer);
// Load content as multiple segments
parsedBuffer = parser.ParseFrom(ReadOnlySequenceFactory.CreateWithContent(bytes));
assert(parsedBuffer);
assert(parsedStream);
}
private string FormatCACLog(AmpMessage req, AmpMessage rsp, long elapsedMS, Google.Protobuf.MessageParser reqParser, Google.Protobuf.MessageParser resParser)
{
string mothedName = req.FriendlyServiceName ?? req.MethodIdentifier;
IMessage reqMsg = null;
IMessage resMsg = null;
if (req.Data != null)
{
reqMsg = reqParser.ParseFrom(req.Data);
}
if (rsp.Data != null)
{
resMsg = resParser.ParseFrom(rsp.Data);
}
var jsonReq = reqMsg == null ? "" : JsonFormatter.Format(reqMsg);
var jsonRsp = resMsg == null ? "" : JsonFormatter.Format(resMsg);
var clientIP = FindFieldValue(reqMsg, "client_ip");
var requestId = FindFieldValue(reqMsg, "x_request_id");
if (string.IsNullOrEmpty(clientIP))
{
clientIP = "UNKNOWN";
}
if (string.IsNullOrEmpty(requestId))
{
requestId = "UNKNOWN";
}
//clientIp,requestId,serviceName, elapsedMS,status_code
return(string.Format("{0}, {1}, {2}, req={3}, res={4}, {5}", clientIP, requestId, mothedName, jsonReq, jsonRsp, elapsedMS, rsp.Code));
}
private string FormatRequestLog(IRpcContext context, AmpMessage req, AmpMessage rsp, long elapsedMS, Google.Protobuf.MessageParser reqParser, Google.Protobuf.MessageParser resParser)
{
string remoteIP = "UNKNOWN";
if (context != null && context.RemoteAddress != null)
{
remoteIP = DotBPE.Rpc.Utils.ParseUtils.ParseEndPointToIPString(context.RemoteAddress);
}
string mothedName = req.FriendlyServiceName ?? req.MethodIdentifier;
IMessage reqMsg = reqParser.ParseFrom(req.Data);
IMessage resMsg = resParser.ParseFrom(rsp.Data);
var jsonReq = JsonFormatter.Format(reqMsg);
var jsonRsp = JsonFormatter.Format(resMsg);
var clientIP = FindFieldValue(reqMsg, "client_ip");
var requestId = FindFieldValue(reqMsg, "x_request_id");
if (string.IsNullOrEmpty(clientIP))
{
clientIP = "UNKNOWN";
}
else
{
clientIP = remoteIP;
}
if (string.IsNullOrEmpty(requestId))
{
requestId = "UNKNOWN";
}
//remoteIP,clientIp,requestId,serviceName,request_data,response_data , elapsedMS ,status_code
return(string.Format("{0}, {1}, {2}, {3}, req={4}, res={5}, {6}, {7}", remoteIP, clientIP, requestId, mothedName, jsonReq, jsonRsp, elapsedMS, rsp.Code));
}
public void TestDiscardUnknownFields()
{
var message = SampleMessages.CreateFullTestAllTypes();
var goldenEmptyMessage = new TestEmptyMessage();
byte[] data = message.ToByteArray();
int fullSize = message.CalculateSize();
Action <IMessage> assertEmpty = msg =>
{
Assert.AreEqual(0, msg.CalculateSize());
Assert.AreEqual(goldenEmptyMessage, msg);
};
Action <IMessage> assertFull = msg => Assert.AreEqual(fullSize, msg.CalculateSize());
// Test the behavior of the parsers with and without discarding, both generic and non-generic.
MessageParser <TestEmptyMessage> retainingParser1 = TestEmptyMessage.Parser;
MessageParser retainingParser2 = retainingParser1;
MessageParser <TestEmptyMessage> discardingParser1 = retainingParser1.WithDiscardUnknownFields(true);
MessageParser discardingParser2 = retainingParser2.WithDiscardUnknownFields(true);
// Test parse from byte[]
assertFull(retainingParser1.ParseFrom(data));
assertFull(retainingParser2.ParseFrom(data));
assertEmpty(discardingParser1.ParseFrom(data));
assertEmpty(discardingParser2.ParseFrom(data));
// Test parse from byte[] with offset
assertFull(retainingParser1.ParseFrom(data, 0, data.Length));
assertFull(retainingParser2.ParseFrom(data, 0, data.Length));
assertEmpty(discardingParser1.ParseFrom(data, 0, data.Length));
assertEmpty(discardingParser2.ParseFrom(data, 0, data.Length));
// Test parse from CodedInputStream
assertFull(retainingParser1.ParseFrom(new CodedInputStream(data)));
assertFull(retainingParser2.ParseFrom(new CodedInputStream(data)));
assertEmpty(discardingParser1.ParseFrom(new CodedInputStream(data)));
assertEmpty(discardingParser2.ParseFrom(new CodedInputStream(data)));
// Test parse from Stream
assertFull(retainingParser1.ParseFrom(new MemoryStream(data)));
assertFull(retainingParser2.ParseFrom(new MemoryStream(data)));
assertEmpty(discardingParser1.ParseFrom(new MemoryStream(data)));
assertEmpty(discardingParser2.ParseFrom(new MemoryStream(data)));
}
public void TestDiscardUnknownFields(IMessage message)
{
var goldenEmptyMessage = new TestEmptyMessage();
byte[] data = message.ToByteArray();
int fullSize = message.CalculateSize();
void AssertEmpty(IMessage msg)
{
Assert.AreEqual(0, msg.CalculateSize());
Assert.AreEqual(goldenEmptyMessage, msg);
}
void AssertFull(IMessage msg) => Assert.AreEqual(fullSize, msg.CalculateSize());
// Test the behavior of the parsers with and without discarding, both generic and non-generic.
MessageParser <TestEmptyMessage> retainingParser1 = TestEmptyMessage.Parser;
MessageParser retainingParser2 = retainingParser1;
MessageParser <TestEmptyMessage> discardingParser1 = retainingParser1.WithDiscardUnknownFields(true);
MessageParser discardingParser2 = retainingParser2.WithDiscardUnknownFields(true);
// Test parse from byte[]
MessageParsingHelpers.AssertReadingMessage(retainingParser1, data, m => AssertFull(m));
MessageParsingHelpers.AssertReadingMessage(retainingParser2, data, m => AssertFull(m));
MessageParsingHelpers.AssertReadingMessage(discardingParser1, data, m => AssertEmpty(m));
MessageParsingHelpers.AssertReadingMessage(discardingParser2, data, m => AssertEmpty(m));
// Test parse from byte[] with offset
AssertFull(retainingParser1.ParseFrom(data, 0, data.Length));
AssertFull(retainingParser2.ParseFrom(data, 0, data.Length));
AssertEmpty(discardingParser1.ParseFrom(data, 0, data.Length));
AssertEmpty(discardingParser2.ParseFrom(data, 0, data.Length));
// Test parse from CodedInputStream
AssertFull(retainingParser1.ParseFrom(new CodedInputStream(data)));
AssertFull(retainingParser2.ParseFrom(new CodedInputStream(data)));
AssertEmpty(discardingParser1.ParseFrom(new CodedInputStream(data)));
AssertEmpty(discardingParser2.ParseFrom(new CodedInputStream(data)));
// Test parse from Stream
AssertFull(retainingParser1.ParseFrom(new MemoryStream(data)));
AssertFull(retainingParser2.ParseFrom(new MemoryStream(data)));
AssertEmpty(discardingParser1.ParseFrom(new MemoryStream(data)));
AssertEmpty(discardingParser2.ParseFrom(new MemoryStream(data)));
}
public static void AssertReadingMessage <T>(MessageParser <T> parser, byte[] bytes, Action <T> assert) where T : IMessage <T>
{
var parsedMsg = parser.ParseFrom(bytes);
assert(parsedMsg);
// Load content as single segment
parsedMsg = parser.ParseFrom(new ReadOnlySequence <byte>(bytes));
assert(parsedMsg);
// Load content as multiple segments
parsedMsg = parser.ParseFrom(ReadOnlySequenceFactory.CreateWithContent(bytes));
assert(parsedMsg);
// Load content as ReadOnlySpan
parsedMsg = parser.ParseFrom(new ReadOnlySpan <byte>(bytes));
assert(parsedMsg);
}
public static void AssertRoundtrip <T>(MessageParser <T> parser, T message, Action <T> additionalAssert = null) where T : IMessage <T>
{
var bytes = message.ToByteArray();
// Load content as single segment
var parsedBuffer = parser.ParseFrom(new ReadOnlySequence <byte>(bytes));
Assert.AreEqual(message, parsedBuffer);
additionalAssert?.Invoke(parsedBuffer);
// Load content as multiple segments
parsedBuffer = parser.ParseFrom(ReadOnlySequenceFactory.CreateWithContent(bytes));
Assert.AreEqual(message, parsedBuffer);
additionalAssert?.Invoke(parsedBuffer);
var parsedStream = parser.ParseFrom(bytes);
Assert.AreEqual(message, parsedStream);
additionalAssert?.Invoke(parsedStream);
}
