public void Protocol_Should_Handle_StreamItemMessage_With_ProtobufObject_Item_And_No_Header(string data)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = new List <Type> {
typeof(TestMessage)
};
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
var item = new TestMessage {
Data = data
};
var streamItemMessage = new StreamItemMessage(INVOCATION_ID, item);
protobufHubProtocol.WriteMessage(streamItemMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultStreamItemMessage);
Assert.True(result);
Assert.NotNull(resultStreamItemMessage);
Assert.IsType <StreamItemMessage>(resultStreamItemMessage);
Assert.Equal(INVOCATION_ID, ((StreamItemMessage)resultStreamItemMessage).InvocationId);
Assert.Equal(item, ((StreamItemMessage)resultStreamItemMessage).Item);
}
public void Protocol_Should_Handle_StreamItemMessage_With_Headers(params string[] kvp)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
var headers = Helpers.GetHeaders(kvp);
var streamItemMessage = new StreamItemMessage(INVOCATION_ID, "foo")
{
Headers = headers
};
protobufHubProtocol.WriteMessage(streamItemMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultStreamItemMessage);
Assert.True(result);
Assert.NotNull(resultStreamItemMessage);
Assert.IsType <StreamItemMessage>(resultStreamItemMessage);
Assert.Equal(INVOCATION_ID, ((StreamItemMessage)resultStreamItemMessage).InvocationId);
Assert.Equal("foo", ((StreamItemMessage)resultStreamItemMessage).Item);
var resultHeaders = ((StreamItemMessage)resultStreamItemMessage).Headers;
Assert.NotEmpty(resultHeaders);
Assert.Equal(resultHeaders.Count, headers.Count);
Assert.Equal(headers, resultHeaders);
}
private void WriteStreamingItemMessage(StreamItemMessage message, ref MessagePackWriter writer)
{
writer.WriteArrayHeader(4);
writer.Write(HubProtocolConstants.StreamItemMessageType);
PackHeaders(message.Headers, ref writer);
writer.Write(message.InvocationId);
WriteArgument(message.Item, ref writer);
}
private void WriteStreamItemMessage(StreamItemMessage message, JsonTextWriter writer)
{
writer.WriteStartObject();
WriteHubInvocationMessageCommon(message, writer, HubProtocolConstants.StreamItemMessageType);
writer.WritePropertyName(ItemPropertyName);
PayloadSerializer.Serialize(writer, message.Item);
writer.WriteEndObject();
}
private void WriteStreamingItemMessage(StreamItemMessage streamItemMessage, Packer packer)
{
packer.PackArrayHeader(4);
packer.Pack(HubProtocolConstants.StreamItemMessageType);
packer.PackString(streamItemMessage.InvocationId);
packer.PackObject(streamItemMessage.Metadata, SerializationContext);
packer.PackObject(streamItemMessage.Item, SerializationContext);
}
private Task ProcessStreamItem(HubConnectionContext connection, StreamItemMessage message)
{
if (!connection.StreamTracker.TryProcessItem(message, out var processTask))
{
Log.UnexpectedStreamItem(_logger);
return(Task.CompletedTask);
}
Log.ReceivedStreamItem(_logger, message);
return(processTask);
}
public bool TryProcessItem(StreamItemMessage message, [NotNullWhen(true)] out Task?task)
{
if (TryGetConverter(message.InvocationId !, out var converter))
{
task = converter.WriteToStream(message.Item);
return(true);
}
task = default;
return(false);
}
// This async void is GROSS but we need to dispatch asynchronously because we're writing to a Channel
// and there's nobody to actually wait for us to finish.
private async void DispatchInvocationStreamItemAsync(StreamItemMessage streamItem, InvocationRequest irq)
{
_logger.ReceivedStreamItem(streamItem.InvocationId);
if (irq.CancellationToken.IsCancellationRequested)
{
_logger.CancelingStreamItem(irq.InvocationId);
}
else if (!await irq.StreamItem(streamItem.Item))
{
_logger.ReceivedStreamItemAfterClose(irq.InvocationId);
}
}
private void WriteStreamItemMessage(StreamItemMessage message, Utf8JsonWriter writer)
{
WriteInvocationId(message, writer);
writer.WritePropertyName(ItemPropertyNameBytes);
if (message.Item == null)
{
writer.WriteNullValue();
}
else
{
JsonSerializer.Serialize(writer, message.Item, message.Item.GetType(), _payloadSerializerOptions);
}
}
public void Setup()
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var types = new[] { typeof(BenchMessage) };
_hubProtocol = new ProtobufHubProtocol(types, logger);
var data = new BenchMessage
{
Email = "*****@*****.**",
Data = new string('@', 512),
Length = 256,
Price = 23451.5436d,
Time = new Google.Protobuf.WellKnownTypes.Timestamp()
{
Seconds = DateTime.UtcNow.Second
}
};
switch (InputArgument)
{
case MessageArgument.IntArguments:
_streamItemMessage = new StreamItemMessage("123", int.MinValue);
break;
case MessageArgument.DoubleArguments:
_streamItemMessage = new StreamItemMessage("123", double.MaxValue);
break;
case MessageArgument.StringArguments:
_streamItemMessage = new StreamItemMessage("123", new string('#', 512));
break;
case MessageArgument.ProtobufArguments:
_streamItemMessage = new StreamItemMessage("123", data);
break;
case MessageArgument.LargeArguments:
data.Data = new string('@', 10240);
_streamItemMessage = new StreamItemMessage("123", data);
break;
}
_serializedMessageRef = _hubProtocol.GetMessageBytes(_streamItemMessage);
}
private void WriteItemMessage(StreamItemMessage streamItemMessage, IBufferWriter <byte> output)
{
var protobufStreamItemMessage = new StreamItemMessageProtobuf
{
InvocationId = streamItemMessage.InvocationId
};
if (streamItemMessage.Headers != null)
{
protobufStreamItemMessage.Headers.Add(streamItemMessage.Headers);
}
var item = _argumentSerializer.SerializeArgument(streamItemMessage.Item);
var packedMessage = MessageDescriptor.PackMessage(HubProtocolConstants.StreamItemMessageType, protobufStreamItemMessage.ToByteArray(), new List <ArgumentDescriptor> {
item
});
output.Write(packedMessage);
}
private HubMessage ParseMessage(string message)
{
ReceivedMessage receivedMessage;
try
{
receivedMessage = JsonConvert.DeserializeObject <ReceivedMessage>(message, PayloadSerializerSettings);
if (receivedMessage.Type == null ||
receivedMessage.Type < HubProtocolConstants.InvocationMessageType ||
receivedMessage.Type > HubProtocolConstants.CloseMessageType)
{
throw new JsonSerializationException($"type:{receivedMessage.Type}");
}
}
catch (JsonSerializationException)
{
Log.Debug("客户端与服务器的协议不一致");
throw;
}
HubMessage hubMessage = null;
switch (receivedMessage.Type)
{
case HubProtocolConstants.InvocationMessageType:
{
try
{
InvocationMessage invocation = JsonConvert.DeserializeObject <InvocationMessage>(message, PayloadSerializerSettings);
hubMessage = invocation;
}
catch (JsonSerializationException)
{
Log.Debug($"客户端与服务器的协议不一致。消息类型：{HubProtocolConstants.InvocationMessageType.ToString()}");
throw;
}
}
break;
case HubProtocolConstants.StreamItemMessageType:
{
try
{
StreamItemMessage streamItem = JsonConvert.DeserializeObject <StreamItemMessage>(message, PayloadSerializerSettings);
hubMessage = streamItem;
}
catch (JsonSerializationException)
{
Log.Debug($"客户端与服务器的协议不一致。消息类型：{HubProtocolConstants.StreamItemMessageType.ToString()}");
throw;
}
}
break;
case HubProtocolConstants.CompletionMessageType:
{
try
{
CompletionMessage completion = JsonConvert.DeserializeObject <CompletionMessage>(message, PayloadSerializerSettings);
if (completion.Result != null)
{
completion.HasResult = true;
}
hubMessage = completion;
}
catch (JsonSerializationException)
{
Log.Debug($"客户端与服务器的协议不一致。消息类型：{HubProtocolConstants.CompletionMessageType.ToString()}");
throw;
}
}
break;
case HubProtocolConstants.StreamInvocationMessageType:
{
try
{
StreamInvocationMessage streamInvocation = JsonConvert.DeserializeObject <StreamInvocationMessage>(message, PayloadSerializerSettings);
hubMessage = streamInvocation;
}
catch (JsonSerializationException)
{
Log.Debug($"客户端与服务器的协议不一致。消息类型：{HubProtocolConstants.StreamInvocationMessageType.ToString()}");
throw;
}
}
break;
case HubProtocolConstants.CancelInvocationMessageType:
{
try
{
CancelInvocationMessage cancelInvocation = JsonConvert.DeserializeObject <CancelInvocationMessage>(message, PayloadSerializerSettings);
hubMessage = cancelInvocation;
}
catch (JsonSerializationException)
{
Log.Debug($"客户端与服务器的协议不一致。消息类型：{HubProtocolConstants.CancelInvocationMessageType.ToString()}");
throw;
}
}
break;
case HubProtocolConstants.PingMessageType:
{
hubMessage = PingMessage.Instance;
}
break;
case HubProtocolConstants.CloseMessageType:
{
try
{
CloseMessage close = JsonConvert.DeserializeObject <CloseMessage>(message, PayloadSerializerSettings);
hubMessage = close;
}
catch (JsonSerializationException)
{
Log.Debug($"客户端与服务器的协议不一致。消息类型：{HubProtocolConstants.CloseMessageType.ToString()}");
throw;
}
}
break;
default:
{
Log.Debug("客户端与服务器的协议不一致。未知的消息类型！");
}
break;
}
return(hubMessage);
}
private bool StreamItemMessagesEqual(StreamItemMessage x, StreamItemMessage y)
{
return(SequenceEqual(x.Headers, y.Headers) &&
string.Equals(x.InvocationId, y.InvocationId, StringComparison.Ordinal) &&
(Equals(x.Item, y.Item) || SequenceEqual(x.Item, y.Item)));
}
public Task ProcessItem(StreamItemMessage message)
{
return(TryGetConverter(message.InvocationId).WriteToStream(message.Item));
}
private Task ProcessStreamItem(HubConnectionContext connection, StreamItemMessage message)
{
Log.ReceivedStreamItem(_logger, message);
return(connection.StreamTracker.ProcessItem(message));
}
public static void ReceivedStreamItem(ILogger logger, StreamItemMessage message)
{
_receivedStreamItem(logger, message.InvocationId, null);
}
public static void ReceivedStreamItem(ILogger logger, StreamItemMessage message) => ReceivedStreamItem(logger, message.InvocationId);
private void WriteStreamItemMessage(StreamItemMessage message, JsonTextWriter writer)
{
WriteInvocationId(message, writer);
writer.WritePropertyName(ItemPropertyName);
PayloadSerializer.Serialize(writer, message.Item);
}
