/// <summary>
/// Proxies the incoming request to the destination server, and the response back to the client.
/// </summary>
/// <remarks>
/// In what follows, as well as throughout in Reverse Proxy, we consider
/// the following picture as illustrative of the Proxy.
/// <code>
/// +-------------------+
/// | Destination +
/// +-------------------+
/// ▲ |
/// (b) | | (c)
/// | ▼
/// +-------------------+
/// | Proxy +
/// +-------------------+
/// ▲ |
/// (a) | | (d)
/// | ▼
/// +-------------------+
/// | Client +
/// +-------------------+
/// </code>
///
/// (a) and (b) show the *request* path, going from the client to the target.
/// (c) and (d) show the *response* path, going from the destination back to the client.
///
/// Normal proxying comprises the following steps:
/// (0) Disable ASP .NET Core limits for streaming requests
/// (1) Create outgoing HttpRequestMessage
/// (2) Setup copy of request body (background) Client --► Proxy --► Destination
/// (3) Copy request headers Client --► Proxy --► Destination
/// (4) Send the outgoing request using HttpMessageInvoker Client --► Proxy --► Destination
/// (5) Copy response status line Client ◄-- Proxy ◄-- Destination
/// (6) Copy response headers Client ◄-- Proxy ◄-- Destination
/// (7-A) Check for a 101 upgrade response, this takes care of WebSockets as well as any other upgradeable protocol.
/// (7-A-1) Upgrade client channel Client ◄--- Proxy ◄--- Destination
/// (7-A-2) Copy duplex streams and return Client ◄--► Proxy ◄--► Destination
/// (7-B) Copy (normal) response body Client ◄-- Proxy ◄-- Destination
/// (8) Copy response trailer headers and finish response Client ◄-- Proxy ◄-- Destination
/// (9) Wait for completion of step 2: copying request body Client --► Proxy --► Destination
///
/// ASP .NET Core (Kestrel) will finally send response trailers (if any)
/// after we complete the steps above and relinquish control.
/// </remarks>
public async ValueTask <ProxyError> ProxyAsync(
HttpContext context,
string destinationPrefix,
HttpMessageInvoker httpClient,
RequestProxyConfig requestConfig,
HttpTransformer transformer)
{
_ = context ?? throw new ArgumentNullException(nameof(context));
_ = destinationPrefix ?? throw new ArgumentNullException(nameof(destinationPrefix));
_ = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
_ = requestConfig ?? throw new ArgumentNullException(nameof(requestConfig));
_ = transformer ?? throw new ArgumentNullException(nameof(transformer));
// HttpClient overload for SendAsync changes response behavior to fully buffered which impacts performance
// See discussion in https://github.com/microsoft/reverse-proxy/issues/458
if (httpClient is HttpClient)
{
throw new ArgumentException($"The http client must be of type HttpMessageInvoker, not HttpClient", nameof(httpClient));
}
ProxyTelemetry.Log.ProxyStart(destinationPrefix);
try
{
var requestAborted = context.RequestAborted;
var isClientHttp2 = ProtocolHelper.IsHttp2(context.Request.Protocol);
// NOTE: We heuristically assume gRPC-looking requests may require streaming semantics.
// See https://github.com/microsoft/reverse-proxy/issues/118 for design discussion.
var isStreamingRequest = isClientHttp2 && ProtocolHelper.IsGrpcContentType(context.Request.ContentType);
// :: Step 1-3: Create outgoing HttpRequestMessage
var(destinationRequest, requestContent) = await CreateRequestMessageAsync(
context, destinationPrefix, transformer, requestConfig, isStreamingRequest, requestAborted);
// :: Step 4: Send the outgoing request using HttpClient
HttpResponseMessage destinationResponse;
var requestTimeoutSource = CancellationTokenSource.CreateLinkedTokenSource(requestAborted);
requestTimeoutSource.CancelAfter(requestConfig?.Timeout ?? DefaultTimeout);
var requestTimeoutToken = requestTimeoutSource.Token;
try
{
ProxyTelemetry.Log.ProxyStage(ProxyStage.SendAsyncStart);
destinationResponse = await httpClient.SendAsync(destinationRequest, requestTimeoutToken);
ProxyTelemetry.Log.ProxyStage(ProxyStage.SendAsyncStop);
}
catch (OperationCanceledException canceledException)
{
if (!requestAborted.IsCancellationRequested && requestTimeoutToken.IsCancellationRequested)
{
ReportProxyError(context, ProxyError.RequestTimedOut, canceledException);
context.Response.StatusCode = StatusCodes.Status504GatewayTimeout;
return(ProxyError.RequestTimedOut);
}
ReportProxyError(context, ProxyError.RequestCanceled, canceledException);
context.Response.StatusCode = StatusCodes.Status502BadGateway;
return(ProxyError.RequestCanceled);
}
catch (Exception requestException)
{
return(await HandleRequestFailureAsync(context, requestContent, requestException));
}
finally
{
requestTimeoutSource.Dispose();
}
// Detect connection downgrade, which may be problematic for e.g. gRPC.
if (isClientHttp2 && destinationResponse.Version.Major != 2)
{
// TODO: Do something on connection downgrade...
Log.HttpDowngradeDetected(_logger);
}
try
{
// :: Step 5: Copy response status line Client ◄-- Proxy ◄-- Destination
// :: Step 6: Copy response headers Client ◄-- Proxy ◄-- Destination
var copyBody = await CopyResponseStatusAndHeadersAsync(destinationResponse, context, transformer);
if (!copyBody)
{
// The transforms callback decided that the response body should be discarded.
destinationResponse.Dispose();
return(ProxyError.None);
}
}
catch (Exception ex)
{
destinationResponse.Dispose();
ReportProxyError(context, ProxyError.ResponseHeaders, ex);
// Clear the response since status code, reason and some headers might have already been copied and we want clean 502 response.
context.Response.Clear();
context.Response.StatusCode = StatusCodes.Status502BadGateway;
return(ProxyError.ResponseHeaders);
}
// :: Step 7-A: Check for a 101 upgrade response, this takes care of WebSockets as well as any other upgradeable protocol.
if (destinationResponse.StatusCode == HttpStatusCode.SwitchingProtocols)
{
return(await HandleUpgradedResponse(context, destinationResponse, requestAborted));
}
// NOTE: it may *seem* wise to call `context.Response.StartAsync()` at this point
// since it looks like we are ready to send back response headers
// (and this might help reduce extra delays while we wait to receive the body from the destination).
// HOWEVER, this would produce the wrong result if it turns out that there is no content
// from the destination -- instead of sending headers and terminating the stream at once,
// we would send headers thinking a body may be coming, and there is none.
// This is problematic on gRPC connections when the destination server encounters an error,
// in which case it immediately returns the response headers and trailing headers, but no content,
// and clients misbehave if the initial headers response does not indicate stream end.
// :: Step 7-B: Copy response body Client ◄-- Proxy ◄-- Destination
var(responseBodyCopyResult, responseBodyException) = await CopyResponseBodyAsync(destinationResponse.Content, context.Response.Body, requestAborted);
if (responseBodyCopyResult != StreamCopyResult.Success)
{
return(await HandleResponseBodyErrorAsync(context, requestContent, responseBodyCopyResult, responseBodyException !));
}
// :: Step 8: Copy response trailer headers and finish response Client ◄-- Proxy ◄-- Destination
await CopyResponseTrailingHeadersAsync(destinationResponse, context, transformer);
if (isStreamingRequest)
{
// NOTE: We must call `CompleteAsync` so that Kestrel will flush all bytes to the client.
// In the case where there was no response body,
// this is also when headers and trailing headers are sent to the client.
// Without this, the client might wait forever waiting for response bytes,
// while we might wait forever waiting for request bytes,
// leading to a stuck connection and no way to make progress.
await context.Response.CompleteAsync();
}
// :: Step 9: Wait for completion of step 2: copying request body Client --► Proxy --► Destination
// NOTE: It is possible for the request body to NOT be copied even when there was an incoming requet body,
// e.g. when the request includes header `Expect: 100-continue` and the destination produced a non-1xx response.
// We must only wait for the request body to complete if it actually started,
// otherwise we run the risk of waiting indefinitely for a task that will never complete.
if (requestContent != null && requestContent.Started)
{
var(requestBodyCopyResult, requestBodyException) = await requestContent.ConsumptionTask;
if (requestBodyCopyResult != StreamCopyResult.Success)
{
// The response succeeded. If there was a request body error then it was probably because the client or destination decided
// to cancel it. Report as low severity.
var error = requestBodyCopyResult switch
{
StreamCopyResult.InputError => ProxyError.RequestBodyClient,
StreamCopyResult.OutputError => ProxyError.RequestBodyDestination,
StreamCopyResult.Canceled => ProxyError.RequestBodyCanceled,
_ => throw new NotImplementedException(requestBodyCopyResult.ToString())
};
ReportProxyError(context, error, requestBodyException !);
return(error);
}
}
}
finally
{
ProxyTelemetry.Log.ProxyStop(context.Response.StatusCode);
}
return(ProxyError.None);
}
private static ValueTask <bool> CopyResponseStatusAndHeadersAsync(HttpResponseMessage source, HttpContext context, HttpTransformer transformer)
{
context.Response.StatusCode = (int)source.StatusCode;
if (!ProtocolHelper.IsHttp2OrGreater(context.Request.Protocol))
{
// Don't explicitly set the field if the default reason phrase is used
if (source.ReasonPhrase != ReasonPhrases.GetReasonPhrase((int)source.StatusCode))
{
context.Features.Get <IHttpResponseFeature>().ReasonPhrase = source.ReasonPhrase;
}
}
// Copies headers
return(transformer.TransformResponseAsync(context, source));
}
private static ValueTask CopyResponseTrailingHeadersAsync(HttpResponseMessage source, HttpContext context, HttpTransformer transformer)
{
// Copies trailers
return(transformer.TransformResponseTrailersAsync(context, source));
}
private async ValueTask <(HttpRequestMessage, StreamCopyHttpContent?)> CreateRequestMessageAsync(HttpContext context, string destinationPrefix,
HttpTransformer transformer, RequestProxyConfig requestConfig, bool isStreamingRequest, CancellationToken requestAborted)
{
// "http://a".Length = 8
if (destinationPrefix == null || destinationPrefix.Length < 8)
{
throw new ArgumentException(nameof(destinationPrefix));
}
var destinationRequest = new HttpRequestMessage();
destinationRequest.Method = RequestUtilities.GetHttpMethod(context.Request.Method);
var upgradeFeature = context.Features.Get <IHttpUpgradeFeature>();
var upgradeHeader = context.Request.Headers[HeaderNames.Upgrade].ToString();
var isUpgradeRequest = (upgradeFeature?.IsUpgradableRequest ?? false)
// Mitigate https://github.com/microsoft/reverse-proxy/issues/255, IIS considers all requests upgradeable.
&& (string.Equals("WebSocket", upgradeHeader, StringComparison.OrdinalIgnoreCase)
// https://github.com/microsoft/reverse-proxy/issues/467 for kubernetes APIs
|| upgradeHeader.StartsWith("SPDY/", StringComparison.OrdinalIgnoreCase));
// Default to HTTP/1.1 for proxying upgradeable requests. This is already the default as of .NET Core 3.1
// Otherwise request what's set in proxyOptions (e.g. default HTTP/2) and let HttpClient negotiate the protocol
// based on VersionPolicy (for .NET 5 and higher). For example, downgrading to HTTP/1.1 if it cannot establish HTTP/2 with the target.
// This is done without extra round-trips thanks to ALPN. We can detect a downgrade after calling HttpClient.SendAsync
// (see Step 3 below). TBD how this will change when HTTP/3 is supported.
destinationRequest.Version = isUpgradeRequest ? ProtocolHelper.Http11Version : (requestConfig?.Version ?? DefaultVersion);
#if NET
destinationRequest.VersionPolicy = isUpgradeRequest ? HttpVersionPolicy.RequestVersionOrLower : (requestConfig?.VersionPolicy ?? DefaultVersionPolicy);
#endif
// :: Step 2: Setup copy of request body (background) Client --► Proxy --► Destination
// Note that we must do this before step (3) because step (3) may also add headers to the HttpContent that we set up here.
var requestContent = SetupRequestBodyCopy(context.Request, isStreamingRequest, requestAborted);
destinationRequest.Content = requestContent;
// :: Step 3: Copy request headers Client --► Proxy --► Destination
await transformer.TransformRequestAsync(context, destinationRequest, destinationPrefix);
if (isUpgradeRequest)
{
RestoreUpgradeHeaders(context, destinationRequest);
}
// Allow someone to custom build the request uri, otherwise provide a default for them.
var request = context.Request;
destinationRequest.RequestUri ??= RequestUtilities.MakeDestinationAddress(destinationPrefix, request.Path, request.QueryString);
Log.Proxying(_logger, destinationRequest.RequestUri);
if (requestConfig?.AllowResponseBuffering != true)
{
context.Features.Get <IHttpResponseBodyFeature>()?.DisableBuffering();
}
// TODO: What if they replace the HttpContent object? That would mess with our tracking and error handling.
return(destinationRequest, requestContent);
}