Add Java client transport fallback

[BrennanConroy]

We added the LongPolling transport to the Java client in #6856

But it currently doesn't do fallback, so the client either connects with the selected transport or it doesn't.

[noamyogev84]

Hey @BrennanConroy i'll try to grab that
Can you get me started with some pin points?

[BrennanConroy]

Sure, the general idea is that we want to first get the negotiate response from the server which can include multiple transports, then we'll loop over all of the transports the client can use and check that the server supports them too and see if the client connects with that transport. If it throws we log and try the next one, repeat until all transports are tried and either we stop on a successful one, or return some sort of error to the user.

Most of the Typescript client code for an example is:

aspnetcore/src/SignalR/clients/ts/signalr/src/HttpConnection.ts

Lines 376 to 408 in 5223b49

	for (const endpoint of transports) {
	const transportOrError = this._resolveTransportOrError(endpoint, requestedTransport, requestedTransferFormat);
	if (transportOrError instanceof Error) {
	// Store the error and continue, we don't want to cause a re-negotiate in these cases
	transportExceptions.push(`${endpoint.transport} failed:`);
	transportExceptions.push(transportOrError);
	} else if (this._isITransport(transportOrError)) {
	this.transport = transportOrError;
	if (!negotiate) {
	try {
	negotiate = await this._getNegotiationResponse(url);
	} catch (ex) {
	return Promise.reject(ex);
	}
	connectUrl = this._createConnectUrl(url, negotiate.connectionToken);
	}
	try {
	await this._startTransport(connectUrl, requestedTransferFormat);
	this.connectionId = negotiate.connectionId;
	return;
	} catch (ex) {
	this._logger.log(LogLevel.Error, `Failed to start the transport '${endpoint.transport}': ${ex}`);
	negotiate = undefined;
	transportExceptions.push(new FailedToStartTransportError(`${endpoint.transport} failed: ${ex}`, HttpTransportType[endpoint.transport]));
	if (this._connectionState !== ConnectionState.Connecting) {
	const message = "Failed to select transport before stop() was called.";
	this._logger.log(LogLevel.Debug, message);
	return Promise.reject(new Error(message));
	}
	}
	}
	}

And for the .NET Client:

aspnetcore/src/SignalR/clients/csharp/Http.Connections.Client/src/HttpConnection.cs

Lines 365 to 424 in 5223b49

	foreach (var transport in negotiationResponse.AvailableTransports!)
	{
	if (!Enum.TryParse<HttpTransportType>(transport.Transport, out var transportType))
	{
	Log.TransportNotSupported(_logger, transport.Transport!);
	transportExceptions.Add(new TransportFailedException(transport.Transport!, "The transport is not supported by the client."));
	continue;
	}
	if (transportType == HttpTransportType.WebSockets && !IsWebSocketsSupported())
	{
	Log.WebSocketsNotSupportedByOperatingSystem(_logger);
	transportExceptions.Add(new TransportFailedException("WebSockets", "The transport is not supported on this operating system."));
	continue;
	}
	if (transportType == HttpTransportType.ServerSentEvents && OperatingSystem.IsBrowser())
	{
	Log.ServerSentEventsNotSupportedByBrowser(_logger);
	transportExceptions.Add(new TransportFailedException("ServerSentEvents", "The transport is not supported in the browser."));
	continue;
	}
	try
	{
	if ((transportType & _httpConnectionOptions.Transports) == 0)
	{
	Log.TransportDisabledByClient(_logger, transportType);
	transportExceptions.Add(new TransportFailedException(transportType.ToString(), "The transport is disabled by the client."));
	}
	else if (!transport.TransferFormats!.Contains(transferFormatString, StringComparer.Ordinal))
	{
	Log.TransportDoesNotSupportTransferFormat(_logger, transportType, transferFormat);
	transportExceptions.Add(new TransportFailedException(transportType.ToString(), $"The transport does not support the '{transferFormat}' transfer format."));
	}
	else
	{
	// The negotiation response gets cleared in the fallback scenario.
	if (negotiationResponse == null)
	{
	negotiationResponse = await GetNegotiationResponseAsync(uri, cancellationToken);
	connectUrl = CreateConnectUrl(uri, negotiationResponse.ConnectionToken);
	}
	Log.StartingTransport(_logger, transportType, uri);
	await StartTransport(connectUrl, transportType, transferFormat, cancellationToken);
	break;
	}
	}
	catch (Exception ex)
	{
	Log.TransportFailed(_logger, transportType, ex);
	transportExceptions.Add(new TransportFailedException(transportType.ToString(), ex.Message, ex));
	// Try the next transport
	// Clear the negotiation response so we know to re-negotiate.
	negotiationResponse = null;
	}
	}