How to transform response body?

[prabh-62]

Thank you for this library. I am running it in front of few APIs + UI projects and everything works flawlessly.

I would like to rewrite response body for some APIs hosted internally. Assuming the response Content-Type is application/json, I would like to replace all occurrences of IP address with some hostname when the API response leaves the company network.

Transform this json payload

{
  "Link": "http://192.168.0.1/Connector/ConnectorService/",
}

to this

{
  "Link": "https://contoso.com/Connector/ConnectorService/",
}

Previously, I have been able to achieve this behaviour using IIS URL Rewrite Module - Outbound rule

[Tratcher]

See #447

[prabh-62]

Thank you for giving me the direction, Chris.

I was able to achieve the expected behaviour using the Middleware. However, I ran into the issue where HTTP request never finishes.

Here is the middleware code. I debugged the middleware and successfully verified that response body does get updated.

using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features;

namespace Frontdoor.Controllers.Middlewares
{
    public class TransformResponseMiddleware
    {
        private readonly RequestDelegate _next;

        public TransformResponseMiddleware(RequestDelegate next)
        {
            _next = next ?? throw new ArgumentNullException(nameof(next));
        }

        public async Task Invoke(HttpContext context)
        {
            // Copy the body to another stream
            using var memoryResponse = new MemoryStream();
            var originalResponse = context.Response.Body;
            context.Response.Body = memoryResponse;
            context.Features.Set<IHttpResponseBodyFeature>(new StreamResponseBodyFeature(memoryResponse));

            await _next.Invoke(context).ConfigureAwait(false);

            // Only care about successful responses with body
            if (!(context.Response.StatusCode == 200 || context.Response.StatusCode == 201))
            {
                await originalResponse.CopyToAsync(memoryResponse).ConfigureAwait(false);
                return;
            }
            // Don't care about non-JSON responses
            if (!(context.Response.ContentType.StartsWith("application/json") || context.Response.ContentType.StartsWith("application/hal+json")))
            {
                await originalResponse.CopyToAsync(memoryResponse).ConfigureAwait(false);
                return;
            }

            var decodedBody = Encoding.UTF8.GetString(memoryResponse.ToArray());

            var replaced = decodedBody.Replace("http://192.168.0.1", "https://contoso.com");
            var streamWriter = new StreamWriter(originalResponse);
            await streamWriter.WriteAsync(replaced).ConfigureAwait(false);
            await streamWriter.FlushAsync().ConfigureAwait(false);

            context.Response.Headers.ContentLength = replaced.Length;
            return;
        }
    }
}

and I put the middleware at top in Configure method

// Startup.cs
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMiddleware<TransformResponseMiddleware>();
    ...
    ...
    app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
                endpoints.MapReverseProxy();
            });
    }
}   

Postman HTTP request never finishes

[Tratcher]

context.Features.Set<IHttpResponseBodyFeature>(new StreamResponseBodyFeature(memoryResponse));

This line is redundant with context.Response.Body = memoryResponse;, you can remove it.

await originalResponse.CopyToAsync(memoryResponse).ConfigureAwait(false);

This is backwards, it should be memoryResponse.Position = 0; await memoryResponse.CopyToAsync(originalResponse).ConfigureAwait(false);

context.Response.Headers.ContentLength = replaced.Length;

You have to set the ContentLength before any writes to the originalResponse. Setting it after causes an exception and the response gets aborted.

[davidfowl]

Just FYI this code is extremely inefficient as it buffers the entire response body in memory and transforms before writing the response. That could bloat memory if there are lots of large outgoing responses

[prabh-62]

David, Understood. How could I make this code more efficient? I am short of ideas

[Tratcher]

Look at the ResponseCompressionMiddleware design. It wraps the response body, does it's activation check on first-write, and streams its processing of the body. It never buffers more that one write. Your text replacing scenario is a bit harder because you have to scan each write for matching byte segments and replace them, and worry about that match happening over a buffer boundary.
https://github.com/dotnet/aspnetcore/blob/master/src/Middleware/ResponseCompression/src/ResponseCompressionMiddleware.cs
https://github.com/dotnet/aspnetcore/blob/master/src/Middleware/ResponseCompression/src/ResponseCompressionBody.cs

[prabh-62]

Chris, I followed the advice (We can ignore buffer boundary edge cases for now until I hit that problem)

Below is the code

BodyWrapperStream.cs

using System;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;

namespace Frontdoor.Middlewares
{
    internal class BodyWrapperStream : Stream
    {
        private readonly HttpContext _context;
        private readonly Stream _bodyOriginalStream;
        private readonly string _externalAddress;
        private bool? _shouldTransform;

        internal BodyWrapperStream(HttpContext context, Stream bodyOriginalStream, string EXTERNAL_ADDRESS)
        {
            _context = context;
            _bodyOriginalStream = bodyOriginalStream;
            _externalAddress = EXTERNAL_ADDRESS;
        }

        protected override void Dispose(bool disposing)
        {
            _shouldTransform = null;
        }

        public override bool CanRead => false;

        public override bool CanSeek => false;

        public override bool CanWrite => _bodyOriginalStream.CanWrite;

        public override long Length
        {
            get { throw new NotSupportedException(); }
        }

        public override long Position
        {
            get { throw new NotSupportedException(); }
            set { throw new NotSupportedException(); }
        }

        public override void Flush()
        {
            _bodyOriginalStream.Flush();
        }

        public override Task FlushAsync(CancellationToken cancellationToken)
        {
            return _bodyOriginalStream.FlushAsync(cancellationToken);
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            throw new NotSupportedException();
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            throw new NotSupportedException();
        }

        public override void SetLength(long value)
        {
            throw new NotSupportedException();
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            ShouldTransform();
            _bodyOriginalStream.Write(buffer, offset, count);
        }

        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)
        {
            var tcs = new TaskCompletionSource<object>(state);
            WriteAsync(buffer, offset, count);
            return tcs.Task;
        }
        public override void EndWrite(IAsyncResult asyncResult)
        {
            if (asyncResult == null)
            {
                throw new ArgumentNullException(nameof(asyncResult));
            }

            var task = (Task)asyncResult;
            task.GetAwaiter().GetResult();
        }

        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            ShouldTransform();
            if (_shouldTransform == false)
            {
                await _bodyOriginalStream.WriteAsync(buffer.AsMemory(offset, count), cancellationToken).ConfigureAwait(false);
            }
            else
            {
                if (!_context.Response.HasStarted)
                {
                    _context.Response.Headers.Remove("Content-Length");
                }

                var decodedBody = Encoding.UTF8.GetString(buffer, offset, count);
                // StringBuilder.Replace is more performant than string.Replace
                var replaced = new StringBuilder(decodedBody, decodedBody.Length * 2);
                replaced.Replace("https://localhost", _externalAddress);

                var byteArray = Encoding.UTF8.GetBytes(replaced.ToString());

                await _bodyOriginalStream.WriteAsync(byteArray.AsMemory(0, byteArray.Length), cancellationToken).ConfigureAwait(false);
            }
        }

        private void ShouldTransform()
        {
            if (!_shouldTransform.HasValue)
            {
                var contentType = _context.Response.ContentType;
                // sourcemap files are powered by webpack dev server -> express
                // var poweredByExpress = context.Response.Headers.ContainsKey("X-Powered-By");
                _shouldTransform = contentType.StartsWith("application/json") || contentType.StartsWith("application/hal+json");
            }
        }
    }
}

TransformResponseMiddleware.cs

using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;

namespace Frontdoor.Middlewares
{
    public class TransformResponseMiddleware
    {
        // Pre-requisite: Put your external URL here before using this middleware
        private const string EXTERNAL_ADDRESS = "https://constoso.com";
        private readonly RequestDelegate _next;

        public TransformResponseMiddleware(RequestDelegate next)
        {
            _next = next ?? throw new ArgumentNullException(nameof(next));
        }

        public async Task Invoke(HttpContext context)
        {
            var bodyStream = context.Response.Body;
            var bodyWrapperStream = new BodyWrapperStream(context, bodyStream, EXTERNAL_ADDRESS);
            context.Response.Body = bodyWrapperStream;

            await _next.Invoke(context).ConfigureAwait(false);

            // Exception: Headers are read-only at this point
            // context.Response.Headers.Add("Content-Length", "1000");

            context.Response.Body = bodyStream;
            bodyWrapperStream.Dispose();
            return;
        }
    }
}

I am able to transform JSON payloads of any size now. However, there is one issue, I am unable to set Content-Length HTTP header

This is a sample response

[Tratcher]

Right, the correct content length can't be set without buffering. Transfer-encoding: chunked is an adequate substitute for most scenarios.