public void Handler(HubMessage hubMessage)
{
Log.Debug($"开始处理 {nameof(CompletionMessage)}");
CompletionMessage message;
try
{
message = hubMessage as CompletionMessage;
}
catch (Exception e)
{
Log.Error($"回调要处理的消息不是 {nameof(CompletionMessage)} 类型", e);
return;
}
if (message == null)
{
Log.Debug($"回调要处理的 {nameof(CompletionMessage)} 类型消息为空");
}
if (!_callBacks.TryGetValue(message.InvocationId, out InvocationRequestCallBack <object> callback))
{
Log.Debug($"Invoke 的回调集合里不存在 InvocationId={message.InvocationId} 的定义");
}
// 回调未定义具体实现
if (callback.Invoke == null)
{
return;
}
try
{
if (message.HasResult)
{
var settings = NewtonsoftJsonHubProtocol.CreateDefaultSerializerSettings();
var resultJson = JsonConvert.SerializeObject(message.Result, settings);
var result = JsonConvert.DeserializeObject(resultJson, callback.ReturnType, settings);
if (!string.IsNullOrEmpty(message.Error))
{
callback.Invoke.BeginInvoke(result, new Exception(message.Error), null, null);
}
else
{
callback.Invoke.BeginInvoke(result, null, null, null);
}
}
else
{
if (!string.IsNullOrEmpty(message.Error))
{
callback.Invoke.BeginInvoke(null, new Exception(message.Error), null, null);
}
else
{
callback.Invoke.BeginInvoke(null, null, null, null);
}
}
}
catch (Exception ex)
{
Log.Error("回调失败", ex);
}
}
public void WriteMessage(string protocolTestDataName)
{
var testData = ProtocolTestData[protocolTestDataName];
var expectedOutput = Frame(testData.Json);
var protocolOptions = new NewtonsoftJsonHubProtocolOptions
{
PayloadSerializerSettings = new JsonSerializerSettings()
{
NullValueHandling = testData.NullValueHandling,
ContractResolver = testData.CamelCase ? new CamelCasePropertyNamesContractResolver() : new DefaultContractResolver()
}
};
var protocol = new NewtonsoftJsonHubProtocol(Options.Create(protocolOptions));
var writer = MemoryBufferWriter.Get();
try
{
protocol.WriteMessage(testData.Message, writer);
var json = Encoding.UTF8.GetString(writer.ToArray());
Assert.Equal(expectedOutput, json);
}
finally
{
MemoryBufferWriter.Return(writer);
}
}
public void GlobalSetup()
{
var arguments = new object[ArgumentCount];
for (var i = 0; i < arguments.Length; i++)
{
arguments[i] = "Hello world!";
}
var writer = MemoryBufferWriter.Get();
try
{
HandshakeProtocol.WriteResponseMessage(HandshakeResponseMessage.Empty, writer);
var handshakeResponseResult = new ReadResult(new ReadOnlySequence <byte>(writer.ToArray()), false, false);
_pipe = new TestDuplexPipe();
_pipe.AddReadResult(new ValueTask <ReadResult>(handshakeResponseResult));
}
finally
{
MemoryBufferWriter.Return(writer);
}
_nextReadTcs = new TaskCompletionSource <ReadResult>();
_pipe.AddReadResult(new ValueTask <ReadResult>(_nextReadTcs.Task));
IHubProtocol hubProtocol;
var hubConnectionBuilder = new HubConnectionBuilder();
if (Protocol == "json")
{
hubProtocol = new NewtonsoftJsonHubProtocol();
}
else
{
hubProtocol = new MessagePackHubProtocol();
}
hubConnectionBuilder.Services.TryAddEnumerable(ServiceDescriptor.Singleton(typeof(IHubProtocol), hubProtocol));
hubConnectionBuilder.WithUrl("http://doesntmatter");
_invocationMessageBytes = hubProtocol.GetMessageBytes(new InvocationMessage(MethodName, arguments));
var delegateConnectionFactory = new DelegateConnectionFactory(endPoint =>
{
var connection = new DefaultConnectionContext();
// prevents keep alive time being activated
connection.Features.Set <IConnectionInherentKeepAliveFeature>(new TestConnectionInherentKeepAliveFeature());
connection.Transport = _pipe;
return(new ValueTask <ConnectionContext>(connection));
});
hubConnectionBuilder.Services.AddSingleton <IConnectionFactory>(delegateConnectionFactory);
_hubConnection = hubConnectionBuilder.Build();
_hubConnection.On(MethodName, arguments.Select(v => v.GetType()).ToArray(), OnInvoke);
_hubConnection.StartAsync().GetAwaiter().GetResult();
}
public void GlobalSetup()
{
_hubLifetimeManager = new DefaultHubLifetimeManager <Hub>(NullLogger <DefaultHubLifetimeManager <Hub> > .Instance);
IHubProtocol protocol;
if (Protocol == "json")
{
protocol = new NewtonsoftJsonHubProtocol();
}
else
{
protocol = new MessagePackHubProtocol();
}
var options = new PipeOptions();
for (var i = 0; i < Connections; ++i)
{
var pair = DuplexPipe.CreateConnectionPair(options, options);
var connection = new DefaultConnectionContext(Guid.NewGuid().ToString(), pair.Application, pair.Transport);
var hubConnection = new HubConnectionContext(connection, Timeout.InfiniteTimeSpan, NullLoggerFactory.Instance);
hubConnection.Protocol = protocol;
_hubLifetimeManager.OnConnectedAsync(hubConnection).GetAwaiter().GetResult();
_hubLifetimeManager.AddToGroupAsync(connection.ConnectionId, TestGroupName).GetAwaiter().GetResult();
_ = ConsumeAsync(connection.Application);
}
_hubContext = new HubContext <Hub>(_hubLifetimeManager);
}
public void ReadToEndOfArgumentArrayOnError()
{
var binder = new TestBinder(new[] { typeof(string) });
var protocol = new NewtonsoftJsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(Frame("{'type':1,'invocationId':'42','target':'foo','arguments':[[],{'target':'foo2'}]}")));
protocol.TryParseMessage(ref data, binder, out var message);
var bindingFailure = Assert.IsType <InvocationBindingFailureMessage>(message);
Assert.Equal("foo", bindingFailure.Target);
}
public void ExtraItemsInMessageAreIgnored(string input)
{
input = Frame(input);
var binder = new TestBinder(paramTypes: new[] { typeof(int), typeof(string) }, returnType: typeof(bool));
var protocol = new NewtonsoftJsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(input));
Assert.True(protocol.TryParseMessage(ref data, binder, out var message));
Assert.NotNull(message);
}
public void InvalidMessages(string input, string expectedMessage)
{
input = Frame(input);
var binder = new TestBinder(Array.Empty <Type>(), typeof(object));
var protocol = new NewtonsoftJsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(input));
var ex = Assert.Throws <InvalidDataException>(() => protocol.TryParseMessage(ref data, binder, out var _));
Assert.Equal(expectedMessage, ex.Message);
}
public void DateTimeReturnValuePreservesUtcKind(string input)
{
var binder = new TestBinder(typeof(DateTime));
var protocol = new NewtonsoftJsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(Frame(input)));
protocol.TryParseMessage(ref data, binder, out var message);
var invocationMessage = Assert.IsType <CompletionMessage>(message);
var dt = Assert.IsType <DateTime>(invocationMessage.Result);
Assert.Equal(DateTimeKind.Utc, dt.Kind);
}
public void ArgumentBindingErrors(string input, string expectedMessage)
{
input = Frame(input);
var binder = new TestBinder(paramTypes: new[] { typeof(int), typeof(string) }, returnType: typeof(bool));
var protocol = new NewtonsoftJsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(input));
protocol.TryParseMessage(ref data, binder, out var message);
var bindingFailure = Assert.IsType <InvocationBindingFailureMessage>(message);
Assert.Equal(expectedMessage, bindingFailure.BindingFailure.SourceException.Message);
}
public void RegisteringMultipleHubProtocolsReplacesWithLatest()
{
var jsonProtocol1 = new NewtonsoftJsonHubProtocol();
var jsonProtocol2 = new NewtonsoftJsonHubProtocol();
var resolver = new DefaultHubProtocolResolver(new[] {
jsonProtocol1,
jsonProtocol2
}, NullLogger <DefaultHubProtocolResolver> .Instance);
var resolvedProtocol = resolver.GetProtocol(jsonProtocol2.Name, null);
Assert.NotSame(jsonProtocol1, resolvedProtocol);
Assert.Same(jsonProtocol2, resolvedProtocol);
}
public void ParseOutOfOrderJson(string outOfOrderJsonTestDataName)
{
var testData = OutOfOrderJsonTestData[outOfOrderJsonTestDataName];
var input = Frame(testData.Json);
var binder = new TestBinder(testData.Message);
var protocol = new NewtonsoftJsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(input));
protocol.TryParseMessage(ref data, binder, out var message);
Assert.Equal(testData.Message, message, TestHubMessageEqualityComparer.Instance);
}
public void DateTimeArgumentPreservesUtcKind(string input)
{
var binder = new TestBinder(new[] { typeof(DateTime) });
var protocol = new NewtonsoftJsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(Frame(input)));
protocol.TryParseMessage(ref data, binder, out var message);
var invocationMessage = Assert.IsType <InvocationMessage>(message);
Assert.Single(invocationMessage.Arguments);
var dt = Assert.IsType <DateTime>(invocationMessage.Arguments[0]);
Assert.Equal(DateTimeKind.Utc, dt.Kind);
}
public void AllProtocolsOnlyReturnsLatestOfSameType()
{
var jsonProtocol1 = new NewtonsoftJsonHubProtocol();
var jsonProtocol2 = new NewtonsoftJsonHubProtocol();
var resolver = new DefaultHubProtocolResolver(new[] {
jsonProtocol1,
jsonProtocol2
}, NullLogger <DefaultHubProtocolResolver> .Instance);
var hubProtocols = resolver.AllProtocols;
Assert.Equal(1, hubProtocols.Count);
Assert.Same(jsonProtocol2, hubProtocols[0]);
}
public void GlobalSetup()
{
IHubProtocol protocol;
if (Protocol == "json")
{
protocol = new NewtonsoftJsonHubProtocol();
}
else
{
// New line in result to trigger SSE formatting
protocol = new NewtonsoftJsonHubProtocol
{
PayloadSerializer = { Formatting = Formatting.Indented }
};
}
HubMessage hubMessage = null;
switch (Input)
{
case Message.NoArguments:
hubMessage = new InvocationMessage("Target", Array.Empty <object>());
break;
case Message.FewArguments:
hubMessage = new InvocationMessage("Target", new object[] { 1, "Foo", 2.0f });
break;
case Message.ManyArguments:
hubMessage = new InvocationMessage("Target", new object[] { 1, "string", 2.0f, true, (byte)9, new[] { 5, 4, 3, 2, 1 }, 'c', 123456789101112L });
break;
case Message.LargeArguments:
hubMessage = new InvocationMessage("Target", new object[] { new string('F', 10240), new string('B', 10240) });
break;
}
_parser = new ServerSentEventsMessageParser();
_rawData = new ReadOnlySequence <byte>(protocol.GetMessageBytes(hubMessage));
var ms = new MemoryStream();
ServerSentEventsMessageFormatter.WriteMessageAsync(_rawData, ms, default).GetAwaiter().GetResult();
_sseFormattedData = ms.ToArray();
}
public void GlobalSetup()
{
_hubLifetimeManager = new DefaultHubLifetimeManager <Hub>(NullLogger <DefaultHubLifetimeManager <Hub> > .Instance);
_connectionIds = new List <string>();
_subsetConnectionIds = new List <string>();
_groupNames = new List <string>();
_userIdentifiers = new List <string>();
var jsonHubProtocol = new NewtonsoftJsonHubProtocol();
for (int i = 0; i < 100; i++)
{
string connectionId = "connection-" + i;
string groupName = "group-" + i % 10;
string userIdentifier = "user-" + i % 20;
AddUnique(_connectionIds, connectionId);
AddUnique(_groupNames, groupName);
AddUnique(_userIdentifiers, userIdentifier);
if (i % 3 == 0)
{
_subsetConnectionIds.Add(connectionId);
}
var connectionContext = new TestConnectionContext
{
ConnectionId = connectionId,
Transport = new TestDuplexPipe(ForceAsync)
};
var contextOptions = new HubConnectionContextOptions()
{
KeepAliveInterval = TimeSpan.Zero,
};
var hubConnectionContext = new HubConnectionContext(connectionContext, contextOptions, NullLoggerFactory.Instance);
hubConnectionContext.UserIdentifier = userIdentifier;
hubConnectionContext.Protocol = jsonHubProtocol;
_hubLifetimeManager.OnConnectedAsync(hubConnectionContext).GetAwaiter().GetResult();
_hubLifetimeManager.AddToGroupAsync(connectionId, groupName);
}
}
public void ParseMessage(string protocolTestDataName)
{
var testData = ProtocolTestData[protocolTestDataName];
var input = Frame(testData.Json);
var protocolOptions = new NewtonsoftJsonHubProtocolOptions
{
PayloadSerializerSettings = new JsonSerializerSettings
{
NullValueHandling = testData.NullValueHandling,
ContractResolver = testData.CamelCase ? new CamelCasePropertyNamesContractResolver() : new DefaultContractResolver()
}
};
var binder = new TestBinder(testData.Message);
var protocol = new NewtonsoftJsonHubProtocol(Options.Create(protocolOptions));
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(input));
protocol.TryParseMessage(ref data, binder, out var message);
Assert.Equal(testData.Message, message, TestHubMessageEqualityComparer.Instance);
}
public VersionedJsonHubProtocol(int version)
{
_version = version;
_innerProtocol = new NewtonsoftJsonHubProtocol();
}
