Can't figure out how to replace the request body

[sander1095]

Describe the bug

Trying to replace the request body is something that is not officially supported but should be possible. See #1473 (comment) for more information about this.

That thread doesn't really provide a real full solution on how to do this. So I create this issue to get this fully cleared up. This is also related to #520 but this seems all a bit bloated and unclear to me.

With this issue I want to get 2 things cleared up:

• How do I change the request body before forwarding with Direct forwarding
• How do I change the request body before forwarding with the normal YARP flow? (Not using direct forwarding but using middleware/transforms instead so it fits better into other yarp configurations)

To Reproduce

Take a look at program.cs from my repro repo:

https://github.com/sander1095/yarp-body-manipulation

info: Yarp.ReverseProxy.Forwarder.HttpForwarder[48]
      Request: An error was encountered before receiving a response.
      System.Net.Http.HttpRequestException: An error occurred while sending the request.
       ---> System.IO.IOException: The request was aborted.
       ---> System.Net.Http.Http2StreamException: The HTTP/2 server reset the stream. HTTP/2 error code 'PROTOCOL_ERROR' (0x1).
         --- End of inner exception stack trace ---
         at System.Net.Http.Http2Connection.ThrowRequestAborted(Exception innerException)
         at System.Net.Http.Http2Connection.Http2Stream.CheckResponseBodyState()
         at System.Net.Http.Http2Connection.Http2Stream.TryEnsureHeaders()
         at System.Net.Http.Http2Connection.Http2Stream.ReadResponseHeadersAsync(CancellationToken cancellationToken)
         at System.Net.Http.Http2Connection.SendAsync(HttpRequestMessage request, Boolean async, CancellationToken cancellationToken)
         --- End of inner exception stack trace ---
         at System.Net.Http.Http2Connection.SendAsync(HttpRequestMessage request, Boolean async, CancellationToken cancellationToken)
         at System.Net.Http.HttpConnectionPool.SendWithVersionDetectionAndRetryAsync(HttpRequestMessage request, Boolean async, Boolean doRequestAuth, CancellationToken cancellationToken)
         at System.Net.Http.DiagnosticsHandler.SendAsyncCore(HttpRequestMessage request, Boolean async, CancellationToken cancellationToken)
         at Yarp.ReverseProxy.Forwarder.HttpForwarder.SendAsync(HttpContext context, String destinationPrefix, HttpMessageInvoker httpClient, ForwarderRequestConfig requestConfig, HttpTransformer transformer)

Further technical details

• YARP v1.0.0
• Windows
• Net 6.0

[MihaZupan]

See #1473 (comment), you are running into the issue where YARP has already captured the request body and won't observe the change you make in the request transform.
This issue was just recently fixed and will be included in the 1.1.0-rc.1 release, which we are releasing later today (#1596).

After that, there is a separate issue where this using on the body will dispose the stream before it is copied.
Consider doing something like this instead:

context.Request.Body = requestContent.ReadAsStream();

How do I change the request body before forwarding with Direct forwarding

With the above tweak and running YARP 1.1.0, your sample does work.

How do I change the request body before forwarding with the normal YARP flow? (Not using direct forwarding but using middleware/transforms instead so it fits better into other yarp configurations)

You don't have to implement a custom transformer for this, you can register a single request transform. See https://microsoft.github.io/reverse-proxy/articles/transforms.html for more info.

builder.Services.AddReverseProxy()
    .LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"))
    .AddTransforms(builder =>
    {
        builder.AddRequestTransform(async context =>
        {
            var httpContext = context.HttpContext;

            string? requestBody = "";
            httpContext.Request.Body.Position = 0;
            using (StreamReader sr = new StreamReader(httpContext.Request.Body, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, leaveOpen: true))
            {
                requestBody = await sr.ReadToEndAsync();
            }

            var replacedContent = requestBody.Replace("%PLACEHOLDER%", "Hello");
            var requestContent = new StringContent(replacedContent, Encoding.UTF8, "application/json");
            httpContext.Request.Body = requestContent.ReadAsStream();
            httpContext.Request.ContentLength = httpContext.Request.Body.Length;
        });
    });

[sander1095]

Hi @MihaZupan . Let me start with THANK YOU, your reply is super clear and extremely helpful! Awesome stuff!

I do still have some questions though. Perhaps you can answer them?

• It's great to hear that 1.1 will support my scenario better and that a RC is on its' way. Do you have any idea when 1.1 will be officially released?
• To piggy back onto my first point... Another comment in this thread you mentioned (Allow request transforms to buffer/replace the body #1473 (comment)) said that their issue was fixed thanks to moving the EnableBuffering() statement. How can their issue be fixed when it should only work on 1.1? 🤔 Are we missing something or is @vzalamea "wrong" with their statement that it could be fixed?
• Your answer om how to do this with "normal" YARP is clear, but I should have specified my question a little bit better. In my example repo I have 2 endpoints that should forward traffic. api/{**catch-all} (or something, im currently on my phone) and also that /track endpoint. I only want to replace the body when the user goes to /track. Could you explain how this would work because now every endpoint would use that transform.
• Lastly, is it a good idea to try and use "normal" YARP with my endpoint, or would this result in an extra performance decrease? I am wary of reducing performance because I'm already changing the request body which isn't great for performance, so perhaps integrating it into normal YARP is even slower..

Thanks again for your awesome answer. I hope you have the time to look into these questions a bit further.

In any case, I hope you have a great weekend!

[MihaZupan]

Do you have any idea when 1.1 will be officially released?

Likely within the next 1-2 months, but we expect 1.1 to contain very few product changes on top of the RC, short of any newly discovered bugs.

How can their issue be fixed when it should only work on 1.1?

Even without 1.1, you can avoid this issue by modifying the body before you call into the forwarder (before the transforms).

request.EnableBuffering()
// or
request.Body = myModifiedBody


await forwarder.SendAsync(...);

or without using the direct forwarder, by adding a custom middleware

app.Use(async (context, next) =>
{
    context.Request.Body = myNewBody;

    await next();
});

app.UseRouting();

app.UseEndpoints(endpoints =>
{
    endpoints.MapReverseProxy();
});

I only want to replace the body when the user goes to /track. Could you explain how this would work because now every endpoint would use that transform.

I take it you have defined different routes for /track and /api in the YARP config.

AddTransforms runs for each route, and you can change how you configure transforms based on the information inside the builder:

.AddTransforms(builder =>
{
    if (builder.Route.RouteId == "trackRoute")
    {
        builder.AddRequestTransform(async context =>
        {
            var httpContext = context.HttpContext;
            // ...
        }
    }
});

Lastly, is it a good idea to try and use "normal" YARP with my endpoint, or would this result in an extra performance decrease?

Modifying the body will likely already have the biggest effect on performance. You will have to watch out for limiting the body sizes, allocations, ...

Calling into the forwarder manually vs letting YARP do it should have a negligible performance impact.

Have a nice weekend yourself :)

[MihaZupan]

@sander1095 FYI 1.1 RC is now live: https://github.com/microsoft/reverse-proxy/releases/tag/v1.1.0-rc.1

[sander1095]

Hey @MihaZupan , just commenting to do a double check on my approach.

Currently I have both versions working; the direct forwarder and normal yarp. 🎉

I am kinda confused about why my normal yarp approach works though. I have created a branch on my repo with this working example, and I just wanna run the code by you.

context.AddRequestTransform(async context =>
{
    var httpContext = context.HttpContext;

    string? requestBody = "";

    using (StreamReader sr = new StreamReader(httpContext.Request.Body, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, leaveOpen: true))
    {
        requestBody = await sr.ReadToEndAsync();
    }

    var replacedContent = requestBody.Replace("%PLACEHOLDER%", "Hello");
    var requestContent = new StringContent(replacedContent, Encoding.UTF8, "application/json");


    httpContext.Request.Body = requestContent.ReadAsStream();
    context.ProxyRequest.Content!.Headers.ContentLength = httpContext.Request.Body.Length;
});

These are my worries:

• I no longer need to use EnableBuffering(). Why is that??
• Changing the httpContext.Request.ContentLength doesn't work, but changing the context.ProxyRequest.Content.Headers.ContentLength did. That is odd, but even weirder is that my example works by replacing the body on the original request, whilst also changing the header of the proxy request. The fact that I am altering both instead of just 1 feels super weird. Does this look OK to you?
• i am also no longer resetting the position?
• Do i maybe have a memory leak because of that leaveOpen at the streamreader?

Thanks! I am looking forward to your feedback!

[MihaZupan]

I no longer need to use EnableBuffering(). Why is that??

Because you are not reading the same Stream twice.
You are reading the original httpContext.Request.Body once, then replace it entirely with a new one.

i am also no longer resetting the position?

Do you mean the context.Request.Body.Position = 0 before calling into StreamReader?
That's never required since you haven't read anything from the stream yet.

Do i maybe have a memory leak because of that leaveOpen at the streamreader?

ASP.NET still owns the lifetime of the original stream, so you should be fine.

If the Stream you replace it with needs disposing, I believe you are responsible for cleaning that up yourself (not the case here since you're using MemoryStream).

Changing the httpContext.Request.ContentLength doesn't work, but changing the context.ProxyRequest.Content.Headers.ContentLength did

The transform you add in AddRequestTransform runs after headers are copied from the HttpContext to the ProxyRequest.

If this was a custom HttpTransformer instead, you could change httpContext.Request.ContentLength before calling base.TransformRequestAsync.

my example works by replacing the body on the original request, whilst also changing the header of the proxy request. The fact that I am altering both instead of just 1 feels super weird. Does this look OK to you?

Yes, that is okay. I agree it's not intuitive, but that's mainly because we haven't focused on this scenario much API-wise.

var requestContent = new StringContent(replacedContent, Encoding.UTF8, "application/json");
httpContext.Request.Body = requestContent.ReadAsStream();

You can change this to

httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(replacedContent));

If you want application/json to be added, you will have to add it to the ProxyRequest.Content.Headers yourself. The StringContent won't do it for you since you aren't using it directly.

[karelz]

Triage: Seems to be resolved, no more actionable thing on our side. Closing.
Feel free to reopen if we missed anything. Thanks!