add support for connecting to Azure Front Door with Azure App Configuration store as an origin

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/AzureAppConfigurationOptions.cs

@@ -302,6 +302,11 @@ public AzureAppConfigurationOptions Connect(string connectionString)
         /// </param>
         public AzureAppConfigurationOptions Connect(IEnumerable<string> connectionStrings)
         {
+            if (Credential is EmptyTokenCredential)
+            {
+                throw new InvalidOperationException("Cannot connect to both Azure App Configuration and CDN at the same time.");
+            }
+
             if (connectionStrings == null || !connectionStrings.Any())
             {
                 throw new ArgumentNullException(nameof(connectionStrings));
@@ -318,6 +323,27 @@ public AzureAppConfigurationOptions Connect(IEnumerable<string> connectionString
             return this;
         }
 
+        /// <summary>
+        /// Connect the provider to CDN endpoint.
+        /// </summary>
+        /// <param name="endpoint">The endpoint of the CDN instance to connect to.</param>
+        public AzureAppConfigurationOptions ConnectCdn(Uri endpoint)
+        {
+            if ((Credential != null && !(Credential is EmptyTokenCredential)) || (ConnectionStrings?.Any() ?? false))
+            {
+                throw new InvalidOperationException("Cannot connect to both Azure App Configuration and CDN at the same time.");
+            }
+
+            if (endpoint == null)
+            {
+                throw new ArgumentNullException(nameof(endpoint));
+            }
+
+            ClientOptions.AddPolicy(new CdnApiVersionPolicy(), HttpPipelinePosition.PerRetry);
+
+            return Connect(new List<Uri>() { endpoint }, new EmptyTokenCredential());
+        }
+
         /// <summary>
         /// Connect the provider to Azure App Configuration using endpoint and token credentials.
         /// </summary>
@@ -345,6 +371,11 @@ public AzureAppConfigurationOptions Connect(Uri endpoint, TokenCredential creden
         /// <param name="credential">Token credential to use to connect.</param>
         public AzureAppConfigurationOptions Connect(IEnumerable<Uri> endpoints, TokenCredential credential)
         {
+            if (Credential is EmptyTokenCredential)
+            {
+                throw new InvalidOperationException("Cannot connect to both Azure App Configuration and CDN at the same time.");
+            }
+
             if (endpoints == null || !endpoints.Any())
             {
                 throw new ArgumentNullException(nameof(endpoints));

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/AzureAppConfigurationProvider.cs

@@ -282,7 +282,7 @@ await ExecuteWithFailOverPolicyAsync(clients, async (client) =>
                                 if (_watchedSettings.TryGetValue(watchedKeyLabel, out ConfigurationSetting watchedKv))
                                 {
                                     await TracingUtils.CallWithRequestTracing(_requestTracingEnabled, RequestType.Watch, _requestTracingOptions,
-                                        async () => change = await client.GetKeyValueChange(watchedKv, cancellationToken).ConfigureAwait(false)).ConfigureAwait(false);
+                                        async () => change = await client.GetKeyValueChange(watchedKv, cancellationToken, !(_options.Credential is EmptyTokenCredential)).ConfigureAwait(false)).ConfigureAwait(false);
                                 }
                                 else
                                 {
@@ -968,7 +968,8 @@ private void SetRequestTracingOptions()
                 IsKeyVaultRefreshConfigured = _options.IsKeyVaultRefreshConfigured,
                 ReplicaCount = _options.Endpoints?.Count() - 1 ?? _options.ConnectionStrings?.Count() - 1 ?? 0,
                 FeatureFlagTracing = _options.FeatureFlagTracing,
-                IsLoadBalancingEnabled = _options.LoadBalancingEnabled
+                IsLoadBalancingEnabled = _options.LoadBalancingEnabled,
+                IsCdnUsed = _options.Credential is EmptyTokenCredential
             };
         }
 

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/AzureAppConfigurationSource.cs

@@ -59,7 +59,14 @@ public IConfigurationProvider Build(IConfigurationBuilder builder)
                     throw new ArgumentException($"Please call {nameof(AzureAppConfigurationOptions)}.{nameof(AzureAppConfigurationOptions.Connect)} to specify how to connect to Azure App Configuration.");
                 }
 
-                provider = new AzureAppConfigurationProvider(new ConfigurationClientManager(clientFactory, endpoints, options.ReplicaDiscoveryEnabled, options.LoadBalancingEnabled), options, _optional);
+                if (options.Credential is EmptyTokenCredential)
+                {
+                    provider = new AzureAppConfigurationProvider(new CdnConfigurationClientManager(clientFactory, endpoints), options, _optional);
+                }
+                else
+                {
+                    provider = new AzureAppConfigurationProvider(new ConfigurationClientManager(clientFactory, endpoints, options.ReplicaDiscoveryEnabled, options.LoadBalancingEnabled), options, _optional);
+                }
             }
             catch (InvalidOperationException ex) // InvalidOperationException is thrown when any problems are found while configuring AzureAppConfigurationOptions or when SDK fails to create a configurationClient.
             {

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/CdnApiVersionPolicy.cs

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+using Azure.Core;
+using Azure.Core.Pipeline;
+using System;
+using System.Collections.Specialized;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Microsoft.Extensions.Configuration.AzureAppConfiguration
+{
+    /// <summary>
+    /// A policy that adds the API version query parameter to HTTP requests.
+    /// </summary>
+    public class CdnApiVersionPolicy : HttpPipelinePolicy
+    {
+        /// <summary>
+        /// Processes the HTTP message by adding the API version query parameter.
+        /// </summary>
+        /// <param name="message">The HTTP message to process.</param>
+        /// <param name="pipeline">The pipeline of HTTP policies to apply.</param>
+        public override void Process(HttpMessage message, ReadOnlyMemory<HttpPipelinePolicy> pipeline)
+        {
+            message.Request.Uri.Reset(AlterApiVersion(message.Request.Uri.ToUri()));
+
+            ProcessNext(message, pipeline);
+        }
+
+        /// <summary>
+        /// Processes the HTTP message asynchronously by adding the API version query parameter.
+        /// </summary>
+        /// <param name="message">The HTTP message to process.</param>
+        /// <param name="pipeline">The pipeline of HTTP policies to apply.</param>
+        /// <returns>A ValueTask representing the asynchronous operation.</returns>
+        public override async ValueTask ProcessAsync(HttpMessage message, ReadOnlyMemory<HttpPipelinePolicy> pipeline)
+        {
+            message.Request.Uri.Reset(AlterApiVersion(message.Request.Uri.ToUri()));
+
+            await ProcessNextAsync(message, pipeline).ConfigureAwait(false);
+        }
+
+        private static Uri AlterApiVersion(Uri uri)
+        {
+            var uriBuilder = new UriBuilder(uri);
+
+            NameValueCollection query = HttpUtility.ParseQueryString(uriBuilder.Query);
+            query["api-version"] = "2024-09-01-preview";
+
+            uriBuilder.Query = query.ToString();
+
+            return uriBuilder.Uri;
+        }
+    }
+}

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/CdnConfigurationClientManager.cs

@@ -0,0 +1,72 @@
+using Azure.Data.AppConfiguration;
+using Microsoft.Extensions.Azure;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+namespace Microsoft.Extensions.Configuration.AzureAppConfiguration
+{
+    internal class CdnConfigurationClientManager : IConfigurationClientManager
+    {
+        private readonly IList<ConfigurationClientWrapper> _clients;
+
+        public CdnConfigurationClientManager(
+            IAzureClientFactory<ConfigurationClient> clientFactory,
+            IEnumerable<Uri> endpoints)
+        {
+            if (clientFactory == null)
+            {
+                throw new ArgumentNullException(nameof(clientFactory));
+            }
+
+            _clients = endpoints
+                .Select(endpoint => new ConfigurationClientWrapper(endpoint, clientFactory.CreateClient(endpoint.AbsoluteUri)))
+                .ToList();
+        }
+
+        public IEnumerable<ConfigurationClient> GetClients()
+        {
+            return _clients.Select(c => c.Client);
+        }
+
+        public void RefreshClients()
+        {
+            return;
+        }
+
+        public bool UpdateSyncToken(Uri endpoint, string syncToken)
+        {
+            if (endpoint == null)
+            {
+                throw new ArgumentNullException(nameof(endpoint));
+            }
+
+            if (string.IsNullOrWhiteSpace(syncToken))
+            {
+                throw new ArgumentNullException(nameof(syncToken));
+            }
+
+            ConfigurationClientWrapper clientWrapper = _clients.SingleOrDefault(c => new EndpointComparer().Equals(c.Endpoint, endpoint));
+
+            if (clientWrapper != null)
+            {
+                clientWrapper.Client.UpdateSyncToken(syncToken);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public Uri GetEndpointForClient(ConfigurationClient client)
+        {
+            if (client == null)
+            {
+                throw new ArgumentNullException(nameof(client));
+            }
+
+            ConfigurationClientWrapper currentClient = _clients.FirstOrDefault(c => c.Client == client);
+
+            return currentClient?.Endpoint;
+        }
+    }
+}

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/Constants/RequestTracingConstants.cs

@@ -33,6 +33,7 @@ internal class RequestTracingConstants
         public const string LoadBalancingEnabledTag = "LB";
         public const string SignalRUsedTag = "SignalR";
         public const string FailoverRequestTag = "Failover";
+        public const string CdnUsedTag = "CDN";
 
         public const string FeatureFlagFilterTypeKey = "Filter";
         public const string CustomFilter = "CSTM";

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/EmptyTokenCredential.cs

@@ -0,0 +1,35 @@
+using Azure.Core;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Extensions.Configuration.AzureAppConfiguration
+{
+    /// <summary>
+    /// A token credential that provides an empty token.
+    /// </summary>
+    internal class EmptyTokenCredential : TokenCredential
+    {
+        /// <summary>
+        /// Gets an empty token.
+        /// </summary>
+        /// <param name="requestContext">The context of the token request.</param>
+        /// <param name="cancellationToken">A cancellation token to cancel the operation.</param>
+        /// <returns>An empty access token.</returns>
+        public override AccessToken GetToken(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        {
+            return new AccessToken(string.Empty, DateTimeOffset.MaxValue);
+        }
+
+        /// <summary>
+        /// Asynchronously gets an empty token.
+        /// </summary>
+        /// <param name="requestContext">The context of the token request.</param>
+        /// <param name="cancellationToken">A cancellation token to cancel the operation.</param>
+        /// <returns>A task that represents the asynchronous operation. The task result contains an empty access token.</returns>
+        public override ValueTask<AccessToken> GetTokenAsync(TokenRequestContext requestContext, CancellationToken cancellationToken)
+        {
+            return new ValueTask<AccessToken>(new AccessToken(string.Empty, DateTimeOffset.MaxValue));
+        }
+    }
+}

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/Extensions/ConfigurationClientExtensions.cs

@@ -16,7 +16,7 @@ namespace Microsoft.Extensions.Configuration.AzureAppConfiguration.Extensions
 {
     internal static class ConfigurationClientExtensions
     {
-        public static async Task<KeyValueChange> GetKeyValueChange(this ConfigurationClient client, ConfigurationSetting setting, CancellationToken cancellationToken)
+        public static async Task<KeyValueChange> GetKeyValueChange(this ConfigurationClient client, ConfigurationSetting setting, CancellationToken cancellationToken, bool makeConditionalRequest = true)
         {
             if (setting == null)
             {
@@ -30,7 +30,7 @@ public static async Task<KeyValueChange> GetKeyValueChange(this ConfigurationCli
 
             try
             {
-                Response<ConfigurationSetting> response = await client.GetConfigurationSettingAsync(setting, onlyIfChanged: true, cancellationToken).ConfigureAwait(false);
+                Response<ConfigurationSetting> response = await client.GetConfigurationSettingAsync(setting, onlyIfChanged: makeConditionalRequest, cancellationToken).ConfigureAwait(false);
                 if (response.GetRawResponse().Status == (int)HttpStatusCode.OK &&
                     !response.Value.ETag.Equals(setting.ETag))
                 {

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/RequestTracingOptions.cs

@@ -63,6 +63,11 @@ internal class RequestTracingOptions
         /// </summary>
         public bool IsFailoverRequest { get; set; } = false;
 
+        /// <summary>
+        /// Flag to indicate wether the request is sent to a CDN.
+        /// </summary>
+        public bool IsCdnUsed { get; set; } = false;
+
         /// <summary>
         /// Checks whether any tracing feature is used.
         /// </summary>

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/TracingUtils.cs

@@ -201,6 +201,11 @@ private static string CreateCorrelationContextHeader(RequestType requestType, Re
                 correlationContextTags.Add(RequestTracingConstants.FailoverRequestTag);
             }
 
+            if (requestTracingOptions.IsCdnUsed)
+            {
+                correlationContextTags.Add(RequestTracingConstants.CdnUsedTag);
+            }
+
             var sb = new StringBuilder();
 
             foreach (KeyValuePair<string, string> kvp in correlationContextKeyValues)