private static void WriteCancelInvocationMessage(CancelInvocationMessage message, ref MessagePackWriter writer)
{
writer.WriteArrayHeader(3);
writer.Write(HubProtocolConstants.CancelInvocationMessageType);
PackHeaders(message.Headers, ref writer);
writer.Write(message.InvocationId);
}
private void WriteCancelInvocationMessage(CancelInvocationMessage cancelInvocationMessage, Packer packer)
{
packer.PackArrayHeader(3);
packer.Pack(HubProtocolConstants.CancelInvocationMessageType);
packer.PackString(cancelInvocationMessage.InvocationId);
packer.PackDictionary(cancelInvocationMessage.Metadata);
}
public void Protocol_Should_Handle_CancelInvocationMessage_With_Header(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 cancelInvocationMessage = new CancelInvocationMessage("123")
{
Headers = headers
};
protobufHubProtocol.WriteMessage(cancelInvocationMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultCancelInvocationMessage);
Assert.True(result);
Assert.NotNull(resultCancelInvocationMessage);
Assert.IsType <CancelInvocationMessage>(resultCancelInvocationMessage);
Assert.Equal("123", ((CancelInvocationMessage)resultCancelInvocationMessage).InvocationId);
var resultHeaders = ((CancelInvocationMessage)resultCancelInvocationMessage).Headers;
Assert.NotEmpty(resultHeaders);
Assert.Equal(resultHeaders.Count, headers.Count);
Assert.Equal(headers, resultHeaders);
}
public void Setup()
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var types = Array.Empty <Type>();
_hubProtocol = new ProtobufHubProtocol(types, logger);
_cancelInvocationMessage = new CancelInvocationMessage("123");
_serializedMessageRef = _hubProtocol.GetMessageBytes(_cancelInvocationMessage);
}
private void WriteCancelInvocationMessage(CancelInvocationMessage cancelInvocationMessage, IBufferWriter <byte> output)
{
var protobufCancelInvocationMessage = new CancelInvocationMessageProtobuf
{
InvocationId = cancelInvocationMessage.InvocationId
};
if (cancelInvocationMessage.Headers != null)
{
protobufCancelInvocationMessage.Headers.Add(cancelInvocationMessage.Headers);
}
var packedMessage = MessageDescriptor.PackMessage(HubProtocolConstants.CancelInvocationMessageType, protobufCancelInvocationMessage.ToByteArray());
output.Write(packedMessage);
}
public void Protocol_Should_Handle_CancelInvocationMessage_Without_Header(string invocationId)
{
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 cancelInvocationMessage = new CancelInvocationMessage(invocationId);
protobufHubProtocol.WriteMessage(cancelInvocationMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultCancelInvocationMessage);
Assert.True(result);
Assert.NotNull(resultCancelInvocationMessage);
Assert.IsType <CancelInvocationMessage>(resultCancelInvocationMessage);
Assert.Equal(invocationId, ((CancelInvocationMessage)resultCancelInvocationMessage).InvocationId);
}
private async Task OnCancelInvocationAsync(CancelInvocationMessage message)
{
var connection = GetHubConnectionContext(message);
if (connection == null)
{
await SendMessageAsync(CompletionMessage.WithError(message.InvocationId, "No connection found."));
return;
}
//// Check if there is an associated active stream and cancel it if it exists.
//// The cts will be removed when the streaming method completes executing
//if (connection.ActiveRequestCancellationSources.TryGetValue(message.InvocationId, out var cts))
//{
// //Logger.CancelStream(message.InvocationId);
// cts.Cancel();
//}
//else
//{
// // Stream can be canceled on the server while client is canceling stream.
// //Logger.UnexpectedCancel();
//}
}
private static void WriteCancelInvocationMessage(CancelInvocationMessage message, Utf8JsonWriter writer)
{
WriteInvocationId(message, writer);
}
private void WriteCancelInvocationMessage(CancelInvocationMessage message, JsonTextWriter writer)
{
writer.WriteStartObject();
WriteHubInvocationMessageCommon(message, writer, HubProtocolConstants.CancelInvocationMessageType);
writer.WriteEndObject();
}
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);
}
