🔧 Yarp.ReverseProxy

    [HttpGet]
    public IActionResult Status()
    {
        return View();
    }

    [HttpPost]
    public IActionResult SetProxy(string ip, string port)
    {
        if (string.IsNullOrEmpty(ip) || string.IsNullOrEmpty(port))
        {
            ViewBag.Error = "IP e Porta sono obbligatori.";
            return View();
        }

        string targetUrl = $"http://{ip}:{port}";
        HttpContext.Session.SetString("TargetUrl", targetUrl);

        // Log the target URL
        _logger.LogInformation($"Target URL set to: {targetUrl}");

        // Aggiorna la configurazione del proxy
        var routes = new List<RouteConfig>
        {
            new RouteConfig
            {
                RouteId = "proxyRoute",
                ClusterId = "backendCluster",
                Match = new RouteMatch
                {
                    // Inoltra tutte le richieste senza rimuovere o modificare il percorso
                    Path = "/{**catch-all}"
                }
            }
        };

        var clusters = new List<ClusterConfig>
        {
            new ClusterConfig
            {
                ClusterId = "backendCluster",
                Destinations = new Dictionary<string, DestinationConfig>
                {
                    { "destination1", new DestinationConfig { Address = targetUrl } }
                }
            }
        };

        _customProxyConfigProvider.UpdateConfig(routes, clusters);

        return RedirectToAction("Proxy");
    }

    public async Task Proxy()
    {
        var targetUrl = HttpContext.Session.GetString("TargetUrl");
        if (string.IsNullOrEmpty(targetUrl))
        {
            Response.StatusCode = 400;
            await Response.WriteAsync("Target URL non configurato.");
            return;
        }

        // Log the target URL before forwarding
        _logger.LogInformation($"Forwarding request to: {targetUrl}");

        var httpContext = HttpContext;
        var forwarderRequestConfig = new ForwarderRequestConfig();

        var error = await _httpForwarder.SendAsync(httpContext, targetUrl, _httpClient, forwarderRequestConfig);

        if (error != ForwarderError.None)
        {
            var errorFeature = httpContext.GetForwarderErrorFeature();
            var exception = errorFeature?.Exception;
            // Gestisci l'errore di inoltro
            _logger.LogError($"Errore di inoltro: {error}, eccezione: {exception?.Message}");
            Response.StatusCode = 500;
            await Response.WriteAsync($"Errore di inoltro: {error}, eccezione: {exception?.Message}");
        }
    }

builder.Services.AddSingleton<CustomProxyConfigProvider>();
builder.Services.AddSingleton<IProxyConfigProvider>(sp => sp.GetRequiredService<CustomProxyConfigProvider>());

builder.Services.AddReverseProxy();
builder.Services.AddSession();
builder.Services.AddHttpForwarder();

builder.Services.AddSingleton(new HttpMessageInvoker(new SocketsHttpHandler()));

...

app.MapControllers();
app.MapReverseProxy();`

public class CustomProxyConfigProvider : IProxyConfigProvider
{
    private volatile CustomProxyConfig _config;
    private readonly CancellationTokenSource _cts = new CancellationTokenSource();

    public CustomProxyConfigProvider()
    {
        _config = new CustomProxyConfig(new List<RouteConfig>(), new List<ClusterConfig>());
    }

    public IProxyConfig GetConfig() => _config;

    public void UpdateConfig(List<RouteConfig> routes, List<ClusterConfig> clusters)
    {
        _config = new CustomProxyConfig(routes, clusters);
        _cts.Cancel();
    }

    private class CustomProxyConfig : IProxyConfig
    {
        public CustomProxyConfig(IReadOnlyList<RouteConfig> routes, IReadOnlyList<ClusterConfig> clusters)
        {
            Routes = routes;
            Clusters = clusters;
            ChangeToken = new CancellationChangeToken(new CancellationTokenSource().Token);
        }

        public IReadOnlyList<RouteConfig> Routes { get; }
        public IReadOnlyList<ClusterConfig> Clusters { get; }
        public IChangeToken ChangeToken { get; }
    }
}