public void ParsingNegotiationMessageThrowsForInvalidMessages(string payload, string expectedMessage)
{
var message = Encoding.UTF8.GetBytes(payload);
var exception = Assert.Throws <InvalidDataException>(() =>
Assert.True(NegotiationProtocol.TryParseMessage(message, out var deserializedMessage)));
Assert.Equal(expectedMessage, exception.Message);
}
public void CanRoundtripNegotiation()
{
var negotiationMessage = new NegotiationMessage(protocol: "dummy");
using (var ms = new MemoryStream())
{
NegotiationProtocol.WriteMessage(negotiationMessage, ms);
Assert.True(NegotiationProtocol.TryParseMessage(ms.ToArray(), out var deserializedMessage));
Assert.NotNull(deserializedMessage);
Assert.Equal(negotiationMessage.Protocol, deserializedMessage.Protocol);
}
}
internal async Task <bool> NegotiateAsync(TimeSpan timeout, IHubProtocolResolver protocolResolver, IUserIdProvider userIdProvider)
{
try
{
using (var cts = new CancellationTokenSource())
{
cts.CancelAfter(timeout);
while (await _connectionContext.Transport.Reader.WaitToReadAsync(cts.Token))
{
while (_connectionContext.Transport.Reader.TryRead(out var buffer))
{
if (NegotiationProtocol.TryParseMessage(buffer, out var negotiationMessage))
{
var protocol = protocolResolver.GetProtocol(negotiationMessage.Protocol, this);
var transportCapabilities = Features.Get <IConnectionTransportFeature>()?.TransportCapabilities
?? throw new InvalidOperationException("Unable to read transport capabilities.");
var dataEncoder = (protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) == 0)
? (IDataEncoder)Base64Encoder
: PassThroughEncoder;
var transferModeFeature = Features.Get <ITransferModeFeature>() ??
throw new InvalidOperationException("Unable to read transfer mode.");
transferModeFeature.TransferMode =
(protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) != 0)
? TransferMode.Binary
: TransferMode.Text;
ProtocolReaderWriter = new HubProtocolReaderWriter(protocol, dataEncoder);
_logger.UsingHubProtocol(protocol.Name);
UserIdentifier = userIdProvider.GetUserId(this);
return(true);
}
}
}
}
}
catch (OperationCanceledException)
{
_logger.NegotiateCanceled();
}
return(false);
}
private async Task <bool> ProcessNegotiate(HubConnectionContext connection)
{
try
{
using (var cts = new CancellationTokenSource())
{
cts.CancelAfter(_hubOptions.NegotiateTimeout);
while (await connection.Input.WaitToReadAsync(cts.Token))
{
while (connection.Input.TryRead(out var buffer))
{
if (NegotiationProtocol.TryParseMessage(buffer, out var negotiationMessage))
{
var protocol = _protocolResolver.GetProtocol(negotiationMessage.Protocol, connection);
var transportCapabilities = connection.Features.Get <IConnectionTransportFeature>()?.TransportCapabilities
?? throw new InvalidOperationException("Unable to read transport capabilities.");
var dataEncoder = (protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) == 0)
? (IDataEncoder)Base64Encoder
: PassThroughEncoder;
var transferModeFeature = connection.Features.Get <ITransferModeFeature>() ??
throw new InvalidOperationException("Unable to read transfer mode.");
transferModeFeature.TransferMode =
(protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) != 0)
? TransferMode.Binary
: TransferMode.Text;
connection.ProtocolReaderWriter = new HubProtocolReaderWriter(protocol, dataEncoder);
_logger.UsingHubProtocol(protocol.Name);
return(true);
}
}
}
}
}
catch (OperationCanceledException)
{
_logger.NegotiateCanceled();
}
return(false);
}
internal async Task <bool> NegotiateAsync(TimeSpan timeout, IList <string> supportedProtocols, IHubProtocolResolver protocolResolver, IUserIdProvider userIdProvider)
{
try
{
using (var cts = new CancellationTokenSource())
{
cts.CancelAfter(timeout);
while (true)
{
var result = await _connectionContext.Transport.Input.ReadAsync(cts.Token);
var buffer = result.Buffer;
var consumed = buffer.End;
var examined = buffer.End;
try
{
if (!buffer.IsEmpty)
{
if (NegotiationProtocol.TryParseMessage(buffer, out var negotiationMessage, out consumed, out examined))
{
Protocol = protocolResolver.GetProtocol(negotiationMessage.Protocol, supportedProtocols, this);
// If there's a transfer format feature, we need to check if we're compatible and set the active format.
// If there isn't a feature, it means that the transport supports binary data and doesn't need us to tell them
// what format we're writing.
var transferFormatFeature = Features.Get <ITransferFormatFeature>();
if (transferFormatFeature != null)
{
if ((transferFormatFeature.SupportedFormats & Protocol.TransferFormat) == 0)
{
throw new InvalidOperationException($"Cannot use the '{Protocol.Name}' protocol on the current transport. The transport does not support the '{Protocol.TransferFormat}' transfer mode.");
}
transferFormatFeature.ActiveFormat = Protocol.TransferFormat;
}
_cachedPingMessage = Protocol.WriteToArray(PingMessage.Instance);
Log.UsingHubProtocol(_logger, Protocol.Name);
UserIdentifier = userIdProvider.GetUserId(this);
if (Features.Get <IConnectionInherentKeepAliveFeature>() == null)
{
// Only register KeepAlive after protocol negotiated otherwise KeepAliveTick could try to write without having a ProtocolReaderWriter
Features.Get <IConnectionHeartbeatFeature>()?.OnHeartbeat(state => ((HubConnectionContext)state).KeepAliveTick(), this);
}
return(true);
}
}
else if (result.IsCompleted)
{
break;
}
}
finally
{
_connectionContext.Transport.Input.AdvanceTo(consumed, examined);
}
}
}
}
catch (OperationCanceledException)
{
Log.NegotiateCanceled(_logger);
}
return(false);
}
internal async Task <bool> NegotiateAsync(TimeSpan timeout, IList <string> supportedProtocols, IHubProtocolResolver protocolResolver, IUserIdProvider userIdProvider)
{
try
{
using (var cts = new CancellationTokenSource())
{
cts.CancelAfter(timeout);
while (true)
{
var result = await _connectionContext.Transport.Input.ReadAsync(cts.Token);
var buffer = result.Buffer;
var consumed = buffer.End;
var examined = buffer.End;
try
{
if (!buffer.IsEmpty)
{
if (NegotiationProtocol.TryParseMessage(buffer, out var negotiationMessage, out consumed, out examined))
{
var protocol = protocolResolver.GetProtocol(negotiationMessage.Protocol, supportedProtocols, this);
var transportCapabilities = Features.Get <IConnectionTransportFeature>()?.TransportCapabilities
?? throw new InvalidOperationException("Unable to read transport capabilities.");
var dataEncoder = (protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) == 0)
? (IDataEncoder)Base64Encoder
: PassThroughEncoder;
var transferModeFeature = Features.Get <ITransferModeFeature>() ??
throw new InvalidOperationException("Unable to read transfer mode.");
transferModeFeature.TransferMode =
(protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) != 0)
? TransferMode.Binary
: TransferMode.Text;
ProtocolReaderWriter = new HubProtocolReaderWriter(protocol, dataEncoder);
_cachedPingMessage = ProtocolReaderWriter.WriteMessage(PingMessage.Instance);
Log.UsingHubProtocol(_logger, protocol.Name);
UserIdentifier = userIdProvider.GetUserId(this);
if (Features.Get <IConnectionInherentKeepAliveFeature>() == null)
{
// Only register KeepAlive after protocol negotiated otherwise KeepAliveTick could try to write without having a ProtocolReaderWriter
Features.Get <IConnectionHeartbeatFeature>()?.OnHeartbeat(state => ((HubConnectionContext)state).KeepAliveTick(), this);
}
return(true);
}
}
else if (result.IsCompleted)
{
break;
}
}
finally
{
_connectionContext.Transport.Input.AdvanceTo(consumed, examined);
}
}
}
}
catch (OperationCanceledException)
{
Log.NegotiateCanceled(_logger);
}
return(false);
}
