What is the correct way to return an error/status code in HttpTransformer?

[VictorioBerra]

Inside TransformRequestAsync for my HttpTransformer I need to check for a specific header value. If this value is not present, I need to stop the proxy request, and immediately return a 401.

IE:

        public override async ValueTask TransformRequestAsync(HttpContext httpContext, HttpRequestMessage proxyRequest, string destinationPrefix)
        {HttpResponseMessage
            // Copy all request headers
            await base.TransformRequestAsync(httpContext, proxyRequest, destinationPrefix);

            var queryContext = new Yarp.ReverseProxy.Transforms.QueryTransformContext(httpContext.Request);

            // Remove a header
            proxyRequest.Headers.Remove("X-DownstreamApi-Token");

            var token = httpContext.Request.Headers["X-DownstreamApi-Token"];
            if (token == Microsoft.Extensions.Primitives.StringValues.Empty)
            {
                // <-------------- return 401?
            }

// ...

Also how to do the same thing in TransformResponseAsync(...) as I assume ill need HttpRequestMessage in one, and HttpResponseMessage in the other.

[karelz]

Being discussed in #1701

[VictorioBerra]

@Tratcher Thanks, I was looking at that, but it seems to really muddy the water of the direct sample.

So I have not quite figured out how to make use of it yet.

The direct sample does not have AddReverseProxy(), it does not have MapReverseProxy(), so if I want to leverage middleware to do this simple task using the Direct sample, I have to bring in a ton of stuff to make that happen.

Another reason I guess issue #1701 needs some validation features.

[VictorioBerra]

Looks like when using IHttpForwarder, middleware doesn't even run.

[Tratcher]

That example doesn't actually require anything from the proxy, it's normal AspNetCore middleware you can put early in your app before IHttpForwarder. How are you setting up IHttpForwarder?

[VictorioBerra]

@Tratcher Ah I thought the .MapReverseProxy(proxyPipeline => proxyPipeline.Use(... was special middleware that was only invoked when theres a match and the proxy takes over. Admittedly I don't know much about the internals yet.

I ended up with the following code that works for me, does this look OK?

// Startup.cs
//

public virtual void Configure(
        IApplicationBuilder application,
        IHttpForwarder forwarder)
    {
        var downstreamAPIOptions= this.configuration
            .GetSection(nameof(DownstreamAPIOptions))
            .Get<DownstreamAPIOptions>();

        // Configure our own HttpMessageInvoker for outbound calls for proxy operations
        var httpClient = new HttpMessageInvoker(new SocketsHttpHandler()
        {
            UseProxy = false,
            AllowAutoRedirect = false,
            AutomaticDecompression = DecompressionMethods.None,
            UseCookies = false,
            ActivityHeadersPropagator = new ReverseProxyPropagator(DistributedContextPropagator.Current)
        });

        // Setup our own request transform class
        var transformer = new CustomTransformer();
        var requestOptions = new ForwarderRequestConfig { ActivityTimeout = TimeSpan.FromSeconds(100) };

        application
            .UseIf(
                this.webHostEnvironment.IsDevelopment(),
                x => x.UseServerTiming())
            .UseForwardedHeaders()
            .UseRouting()
            .UseIf(
                this.webHostEnvironment.IsDevelopment(),
                x => x.UseDeveloperExceptionPage())
            .UseStaticFiles()
            .UseSerilogRequestLogging()
            .UseAuthentication()
            .UseAuthorization()
            .UseEndpoints(
                builder =>
                {
                    builder.MapHealthChecks("/status");
                    builder.MapHealthChecks("/status/self", new HealthCheckOptions() { Predicate = _ => false });

                    builder.Map("/v1/users/{**catch-all}", async httpContext =>
                    {
                        // page query string parameter is required
                        if (httpContext.Request.Query["page"] == StringValues.Empty)
                        {
                            httpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
                            return;
                        }

                        // X-DownstreamApi-Token header value is required
                        var token = httpContext.Request.Headers["X-DownstreamApi-Token"];
                        if (token == StringValues.Empty)
                        {
                            httpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
                            return;
                        }

                        var error = await forwarder.SendAsync(httpContext, downstreamAPIOptions.BaseUri, httpClient, requestOptions, transformer);

                        // Check if the proxy operation was successful
                        if (error != ForwarderError.None)
                        {
                            var errorFeature = httpContext.Features.Get<IForwarderErrorFeature>();
                            var exception = errorFeature.Exception;
                        }
                    })
                    .AllowAnonymous();
                    //.RequireAuthorization();
                });
    }

[Tratcher]

Looks good.