private ServiceMessage CreateMessage(string connectionId, string methodName, object[] args, ClientConnectionContext serviceConnectionContext)
{
IDictionary <string, ReadOnlyMemory <byte> > payloads;
if (serviceConnectionContext.Protocol != null)
{
payloads = new Dictionary <string, ReadOnlyMemory <byte> >()
{
{ serviceConnectionContext.Protocol, SerializeProtocol(serviceConnectionContext.Protocol, methodName, args) }
};
}
else
{
payloads = SerializeAllProtocols(methodName, args);
}
// don't use ConnectionDataMessage here, since handshake message is also wrapped into ConnectionDataMessage.
// otherwise it may cause the handshake failure due to hub invocation message is sent to client before handshake message, when there's high preasure on server.
// do use ConnectionDataMessage when the message is sent from client.
var message = new MultiConnectionDataMessage(new[] { connectionId }, payloads).WithTracingId();
if (message.TracingId != null)
{
MessageLog.StartToSendMessageToConnections(Logger, message);
}
return(message);
}
public static void StartToSendMessageToConnections(ILogger logger, MultiConnectionDataMessage message)
{
if (!Enabled())
{
return;
}
var connections = string.Join(", ", message.ConnectionList);
_startToSendMessageToConnections(logger, message.TracingId, message.ConnectionList.Count, connections, null);
}
public override Task SendConnectionsAsync(IReadOnlyList <string> connectionIds, string methodName, object[] args, CancellationToken cancellationToken = default)
{
if (IsInvalidArgument(connectionIds))
{
throw new ArgumentException(NullOrEmptyStringErrorMessage, nameof(connectionIds));
}
if (IsInvalidArgument(methodName))
{
throw new ArgumentException(NullOrEmptyStringErrorMessage, nameof(methodName));
}
var message = new MultiConnectionDataMessage(connectionIds, SerializeAllProtocols(methodName, args)).WithTracingId();
Log.StartToSendMessageToConnections(Logger, message);
return(WriteAsync(message));
}
public override Task SendConnectionAsync(string connectionId, string methodName, object[] args, CancellationToken cancellationToken = default)
{
if (IsInvalidArgument(connectionId))
{
throw new ArgumentException(NullOrEmptyStringErrorMessage, nameof(connectionId));
}
if (IsInvalidArgument(methodName))
{
throw new ArgumentException(NullOrEmptyStringErrorMessage, nameof(methodName));
}
if (_clientConnectionManager.ClientConnections.TryGetValue(connectionId, out var serviceConnectionContext))
{
var message = new MultiConnectionDataMessage(new[] { connectionId }, SerializeAllProtocols(methodName, args));
// Write directly to this connection
return(serviceConnectionContext.ServiceConnection.WriteAsync(message));
}
return(base.SendConnectionAsync(connectionId, methodName, args, cancellationToken));
}
private ServiceMessage CreateMessage(string connectionId, string methodName, object[] args, ClientConnectionContext serviceConnectionContext)
{
if (serviceConnectionContext.Protocol != null)
{
var message = new ConnectionDataMessage(connectionId, SerializeProtocol(serviceConnectionContext.Protocol, methodName, args)).WithTracingId();
if (message.TracingId != null)
{
MessageLog.StartToSendMessageToConnection(Logger, message);
}
return(message);
}
else
{
var message = new MultiConnectionDataMessage(new[] { connectionId }, SerializeAllProtocols(methodName, args)).WithTracingId();
if (message.TracingId != null)
{
MessageLog.StartToSendMessageToConnections(Logger, message);
}
return(message);
}
}
public override async Task SendConnectionAsync(string connectionId, string methodName, object[] args, CancellationToken cancellationToken = default)
{
if (IsInvalidArgument(connectionId))
{
throw new ArgumentException(NullOrEmptyStringErrorMessage, nameof(connectionId));
}
if (IsInvalidArgument(methodName))
{
throw new ArgumentException(NullOrEmptyStringErrorMessage, nameof(methodName));
}
if (_clientConnectionManager.ClientConnections.TryGetValue(connectionId, out var serviceConnectionContext))
{
var message = new MultiConnectionDataMessage(new[] { connectionId }, SerializeAllProtocols(methodName, args)).WithTracingId();
if (message.TracingId != null)
{
MessageLog.StartToSendMessageToConnections(Logger, message);
}
try
{
// Write directly to this connection
await serviceConnectionContext.ServiceConnection.WriteAsync(message);
if (message.TracingId != null)
{
MessageLog.SucceededToSendMessage(Logger, message);
}
return;
}
catch (Exception ex)
{
MessageLog.FailedToSendMessage(Logger, message, ex);
throw;
}
}
await base.SendConnectionAsync(connectionId, methodName, args, cancellationToken);
}
private bool MultiConnectionDataMessagesEqual(MultiConnectionDataMessage x, MultiConnectionDataMessage y)
{
return(SequenceEqual(x.ConnectionList, y.ConnectionList) && PayloadsEqual(x.Payloads, y.Payloads));
}
