[Container] Add OutputCache configuration from file

src/Application/Program.cs

@@ -5,6 +5,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Yarp.ReverseProxy.Configuration;
 
 
 // Load configuration
@@ -26,13 +27,12 @@
 
 // Configure YARP
 builder.AddServiceDefaults();
-builder.Services.AddServiceDiscovery();
+builder.Services.AddServiceDiscovery()
+                .AddOutputCache(builder.Configuration.GetSection("OutputCache"));
 builder.Services.AddReverseProxy()
                 .LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"))
                 .AddServiceDiscoveryDestinationResolver();
 
-Console.WriteLine(builder.Configuration.GetSection("ReverseProxy").Value);
-
 var app = builder.Build();
 app.MapReverseProxy();
 

src/Application/Yarp.Application.csproj

@@ -7,13 +7,13 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <AssemblyName>yarp</AssemblyName>
+    <EnableConfigurationBindingGenerator>true</EnableConfigurationBindingGenerator>
   </PropertyGroup>
 
   <!-- Used by publishing infrastructure to get the version to use for blob publishing -->
   <Target Name="ReturnPackageVersion" Returns="$(PackageVersion)" />
 
   <ItemGroup>
-    <PackageReference Include="Yarp.ReverseProxy" Version="$(YarpNugetVersion)" />
     <PackageReference Include="Microsoft.Extensions.ServiceDiscovery" Version="$(MicrosoftExtensionsServiceDiscovery)" />
     <PackageReference Include="Microsoft.Extensions.ServiceDiscovery.Yarp" Version="$(MicrosoftExtensionsServiceDiscoveryYarp)" />
 
@@ -25,4 +25,8 @@
     <PackageReference Include="AspNetCore.HealthChecks.ApplicationStatus" Version="$(AspNetCoreHealthChecksApplicationStatus)" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\ReverseProxy\Yarp.ReverseProxy.csproj" />
+  </ItemGroup>
+
 </Project>

src/ReverseProxy/Configuration/Middlewares/OutputCacheConfig.cs

@@ -0,0 +1,122 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.OutputCaching;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Yarp.ReverseProxy.Configuration;
+
+/// <summary>
+/// Configuration for <see cref="OutputCacheOptions"/>
+/// </summary>
+public sealed record OutputCacheConfig
+{
+    /// <inheritdoc cref="OutputCacheOptions.SizeLimit"/>
+    public long SizeLimit { get; set; } = 100 * 1024 * 1024;
+
+    /// <inheritdoc cref="OutputCacheOptions.MaximumBodySize"/>
+    public long MaximumBodySize { get; set; } = 64 * 1024 * 1024;
+
+    /// <inheritdoc cref="OutputCacheOptions.DefaultExpirationTimeSpan"/>
+    public TimeSpan DefaultExpirationTimeSpan { get; set; } = TimeSpan.FromSeconds(60);
+
+    /// <inheritdoc cref="OutputCacheOptions.UseCaseSensitivePaths"/>
+    public bool UseCaseSensitivePaths { get; set; }
+
+    /// <summary>
+    /// Policies that will be added with <see cref="OutputCacheOptions.AddBasePolicy(Action{OutputCachePolicyBuilder}, bool)"/>
+    /// </summary>
+    public IDictionary<string, NamedCacheConfig> NamedPolicies { get; set; } = new Dictionary<string, NamedCacheConfig>(StringComparer.OrdinalIgnoreCase);
+}
+
+/// <summary>
+/// Configuration for <see cref="OutputCachePolicyBuilder"/>
+/// </summary>
+public sealed record NamedCacheConfig
+{
+    /// <summary>
+    /// Flag to exclude or not the default policy
+    /// </summary>
+    public bool ExcludeDefaultPolicy { get; set; }
+
+    /// <inheritdoc cref="OutputCachePolicyBuilder.Expire(TimeSpan)"/>
+    public TimeSpan? ExpirationTimeSpan { get; set; }
+
+    /// <inheritdoc cref="OutputCachePolicyBuilder.NoCache"/>
+    public bool NoCache { get; set; }
+
+    /// <inheritdoc cref="OutputCachePolicyBuilder.SetVaryByQuery(string[])"/>
+    public string[]? VaryByQueryKeys { get; set; }
+
+    /// <inheritdoc cref="OutputCachePolicyBuilder.SetVaryByHeader(string[])"/>
+    public string[]? VaryByHeaders { get; set; }
+}
+
+/// <summary>
+/// Collections of extensions to configure OutputCache
+/// </summary>
+public static class OutputCacheConfigExtensions
+{
+    /// <summary>
+    /// Add and configure OuputCache
+    /// </summary>
+    public static IServiceCollection AddOutputCache(this IServiceCollection services, IConfiguration config)
+    {
+        if (config == null)
+        {
+            return services;
+        }
+
+        var outputCacheConfig = config.Get<OutputCacheConfig>();
+
+        if (outputCacheConfig != null)
+        {
+            services.AddOutputCache(outputCacheConfig);
+        }
+
+        return services;
+    }
+
+    /// <summary>
+    /// Add and configure OuputCache
+    /// </summary>
+    public static IServiceCollection AddOutputCache(this IServiceCollection services, OutputCacheConfig config)
+    {
+        return services.AddOutputCache(options =>
+        {
+            options.SizeLimit = config.SizeLimit;
+            options.MaximumBodySize = config.MaximumBodySize;
+            options.DefaultExpirationTimeSpan = config.DefaultExpirationTimeSpan;
+            options.UseCaseSensitivePaths = config.UseCaseSensitivePaths;
+
+            foreach (var policy  in config.NamedPolicies)
+            {
+                options.AddPolicy(policy.Key,
+                    builder => PolicyBuilder(builder, policy.Value),
+                    policy.Value.ExcludeDefaultPolicy);
+            }
+        });
+    }
+
+    private static void PolicyBuilder(OutputCachePolicyBuilder builder, NamedCacheConfig policy)
+    {
+        if (policy.ExpirationTimeSpan.HasValue)
+            builder.Expire(policy.ExpirationTimeSpan.Value);
+
+        if (policy.NoCache)
+            builder.NoCache();
+
+        if (policy.VaryByQueryKeys != null)
+            builder.SetVaryByQuery(policy.VaryByQueryKeys);
+
+        if (policy.VaryByHeaders != null)
+            builder.SetVaryByHeader(policy.VaryByHeaders);
+    }
+}

src/ReverseProxy/Yarp.ReverseProxy.csproj

@@ -10,6 +10,8 @@
     <IsAotCompatible>true</IsAotCompatible>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageTags>yarp;dotnet;reverse-proxy;aspnetcore</PackageTags>
+    <EnableConfigurationBindingGenerator>true</EnableConfigurationBindingGenerator>
+    <InterceptorsNamespaces>$(InterceptorsNamespaces);Microsoft.Extensions.Configuration.Binder.SourceGeneration</InterceptorsNamespaces>
   </PropertyGroup>
 
   <ItemGroup>

test/ReverseProxy.Tests/Configuration/OutputCacheConfigTests.cs

@@ -0,0 +1,93 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Yarp.ReverseProxy.Configuration;
+
+public class OutputCacheConfigTests
+{
+    [Fact]
+    public async Task All_Options_Added()
+    {
+        var config = new OutputCacheConfig();
+        config.DefaultExpirationTimeSpan = TimeSpan.FromSeconds(1);
+        config.MaximumBodySize = 10;
+        config.SizeLimit = 20;
+        config.UseCaseSensitivePaths = true;
+        config.NamedPolicies.Add("test1", new NamedCacheConfig { ExpirationTimeSpan = TimeSpan.FromSeconds(5), ExcludeDefaultPolicy = true });
+        config.NamedPolicies.Add("test2", new NamedCacheConfig { ExpirationTimeSpan = TimeSpan.FromSeconds(15), ExcludeDefaultPolicy = false });
+        config.NamedPolicies.Add("test3", new NamedCacheConfig { ExpirationTimeSpan = TimeSpan.FromSeconds(3), ExcludeDefaultPolicy = true, VaryByHeaders = new[] { "X-SomeHeader" } });
+
+        var builder = WebApplication.CreateBuilder();
+        builder.Services.AddOutputCache(config)
+                        .AddReverseProxy();
+
+        var app = builder.Build();
+
+        var policies = app.Services.GetRequiredService<IYarpOutputCachePolicyProvider>();
+        var test1 = await policies.GetPolicyAsync("test1");
+        var test2 = await policies.GetPolicyAsync("test2");
+        var test3 = await policies.GetPolicyAsync("test3");
+
+        Assert.NotNull(test1);
+        Assert.NotNull(test2);
+        Assert.NotNull(test3);
+    }
+
+    [Fact]
+    public async Task All_Options_Added_Json()
+    {
+        var json =
+            """
+            {
+                "OutputCache": {
+                    "DefaultExpirationTimeSpan": "00:05:00",
+                    "MaximumBodySize": 10,
+                    "SizeLimit": 20,
+                    "UseCaseSensitivePaths": true,
+                    "NamedPolicies": {
+                        "test1": {
+                            "ExpirationTimeSpan": "00:05:00",
+                            "ExcludeDefaultPolicy": true
+                        },
+                        "test2": {
+                            "ExpirationTimeSpan": "00:15:00",
+                            "ExcludeDefaultPolicy": false
+                        },
+                        "test3": {
+                            "ExpirationTimeSpan": "00:03:00",
+                            "ExcludeDefaultPolicy": true,
+                            "VaryByHeaders": [ "X-SomeHeader" ]
+                        }
+                    }
+                }
+            }
+            """;
+        var configBuilder = new ConfigurationBuilder();
+        var stream = new MemoryStream(Encoding.UTF8.GetBytes(json));
+        var config = configBuilder.AddJsonStream(stream).Build();
+
+        var builder = WebApplication.CreateBuilder();
+        builder.Services.AddOutputCache(config.GetSection("OutputCache"))
+                        .AddReverseProxy();
+
+        var app = builder.Build();
+
+        var policies = app.Services.GetRequiredService<IYarpOutputCachePolicyProvider>();
+        var test1 = await policies.GetPolicyAsync("test1");
+        var test2 = await policies.GetPolicyAsync("test2");
+        var test3 = await policies.GetPolicyAsync("test3");
+
+        Assert.NotNull(test1);
+        Assert.NotNull(test2);
+        Assert.NotNull(test3);
+    }
+}