Extend service discovery to support Consul-based DNS lookups:

- Enable specifying how to construct the DNS SRV query
- Enable adding the Consul DNS server host/port

Author: bart-vmware

src/Libraries/Microsoft.Extensions.ServiceDiscovery.Dns/DnsSrvServiceEndpointProviderFactory.cs

@@ -22,6 +22,8 @@ internal sealed partial class DnsSrvServiceEndpointProviderFactory(
     /// <inheritdoc/>
     public bool TryCreateProvider(ServiceEndpointQuery query, [NotNullWhen(true)] out IServiceEndpointProvider? provider)
     {
+        var optionsValue = options.CurrentValue;
+
         // If a default namespace is not specified, then this provider will attempt to infer the namespace from the service name, but only when running inside Kubernetes.
         // Kubernetes DNS spec: https://github.com/kubernetes/dns/blob/master/docs/specification.md
         // SRV records are available for headless services with named ports.
@@ -30,15 +32,16 @@ public bool TryCreateProvider(ServiceEndpointQuery query, [NotNullWhen(true)] ou
         // Otherwise, the namespace can be read from /var/run/secrets/kubernetes.io/serviceaccount/namespace and combined with an assumed suffix of "svc.cluster.local".
         // The protocol is assumed to be "tcp".
         // The portName is the name of the port in the service definition. If the serviceName parses as a URI, we use the scheme as the port name, otherwise "default".
-        if (string.IsNullOrWhiteSpace(_querySuffix))
+        if (optionsValue.GetQueryText == null && string.IsNullOrWhiteSpace(_querySuffix))
         {
             DnsServiceEndpointProviderBase.Log.NoDnsSuffixFound(logger, query.ToString()!);
             provider = default;
             return false;
         }
 
-        var portName = query.EndpointName ?? "default";
-        var srvQuery = $"_{portName}._tcp.{query.ServiceName}.{_querySuffix}";
+        var srvQuery = optionsValue.GetQueryText != null
+            ? optionsValue.GetQueryText(query)
+            : optionsValue.GetDefaultQueryText(query);
         provider = new DnsSrvServiceEndpointProvider(query, srvQuery, hostName: query.ServiceName, options, logger, resolver, timeProvider);
         return true;
     }

src/Libraries/Microsoft.Extensions.ServiceDiscovery.Dns/DnsSrvServiceEndpointProviderOptions.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.Extensions.ServiceDiscovery.Dns.Resolver;
+
 namespace Microsoft.Extensions.ServiceDiscovery.Dns;
 
 /// <summary>
@@ -28,6 +30,11 @@ public class DnsSrvServiceEndpointProviderOptions
     /// </summary>
     public double RetryBackOffFactor { get; set; } = 2;
 
+    /// <summary>
+    /// Gets or sets the options used to configure the resolver's behavior.
+    /// </summary>
+    public ResolverOptions ResolverOptions { get; set; } = new();
+
     /// <summary>
     /// Gets or sets the default DNS query suffix for services resolved via this provider.
     /// </summary>
@@ -36,8 +43,19 @@ public class DnsSrvServiceEndpointProviderOptions
     /// </remarks>
     public string? QuerySuffix { get; set; }
 
+    /// <summary>
+    /// Gets or sets a delegate that generates a DNS SRV query from a specified <see cref="ServiceEndpointQuery"/> instance.
+    /// </summary>
+    public Func<ServiceEndpointQuery, string>? GetQueryText { get; set; }
+
     /// <summary>
     /// Gets or sets a delegate used to determine whether to apply host name metadata to each resolved endpoint. Defaults to <c>false</c>.
     /// </summary>
     public Func<ServiceEndpoint, bool> ShouldApplyHostNameMetadata { get; set; } = _ => false;
+
+    internal string GetDefaultQueryText(ServiceEndpointQuery query)
+    {
+        var portName = query.EndpointName ?? "default";
+        return $"_{portName}._tcp.{query.ServiceName}.{QuerySuffix}";
+    }
 }

src/Libraries/Microsoft.Extensions.ServiceDiscovery.Dns/Resolver/DnsResolver.cs

@@ -9,8 +9,10 @@
 using System.Net.Sockets;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
 
 namespace Microsoft.Extensions.ServiceDiscovery.Dns.Resolver;
 
@@ -28,16 +30,26 @@ internal sealed partial class DnsResolver : IDnsResolver, IDisposable
     private readonly TimeProvider _timeProvider;
     private readonly ILogger<DnsResolver> _logger;
 
-    public DnsResolver(TimeProvider timeProvider, ILogger<DnsResolver> logger) : this(timeProvider, logger, OperatingSystem.IsLinux() || OperatingSystem.IsMacOS() ? ResolvConf.GetOptions() : NetworkInfo.GetOptions())
-    {
-    }
-
-    internal DnsResolver(TimeProvider timeProvider, ILogger<DnsResolver> logger, ResolverOptions options)
+    public DnsResolver(TimeProvider timeProvider, ILogger<DnsResolver> logger, ResolverOptions options)
     {
         _timeProvider = timeProvider;
         _logger = logger;
         _options = options;
-        Debug.Assert(_options.Servers.Count > 0);
+
+        if (_options.Servers.Count == 0)
+        {
+            foreach (var server in OperatingSystem.IsLinux() || OperatingSystem.IsMacOS()
+                ? ResolvConf.GetServers()
+                : NetworkInfo.GetServers())
+            {
+                _options.Servers.Add(server);
+            }
+
+            if (_options.Servers.Count == 0)
+            {
+                throw new ArgumentException("At least one DNS server is required.", nameof(options));
+            }
+        }
 
         if (options.Timeout != Timeout.InfiniteTimeSpan)
         {
@@ -50,14 +62,24 @@ internal DnsResolver(ResolverOptions options) : this(TimeProvider.System, NullLo
     {
     }
 
-    internal DnsResolver(IEnumerable<IPEndPoint> servers) : this(new ResolverOptions(servers.ToArray()))
+    internal DnsResolver(IEnumerable<IPEndPoint> servers) : this(new ResolverOptions { Servers = servers.ToArray() })
     {
     }
 
-    internal DnsResolver(IPEndPoint server) : this(new ResolverOptions(server))
+    internal DnsResolver(IPEndPoint server) : this(new ResolverOptions { Servers = [server] })
     {
     }
 
+    internal static DnsResolver Create(IServiceProvider serviceProvider)
+    {
+        ArgumentNullException.ThrowIfNull(serviceProvider);
+
+        var resolverOptions = serviceProvider.GetRequiredService<IOptions<DnsSrvServiceEndpointProviderOptions>>().Value.ResolverOptions;
+        var timeProvider = serviceProvider.GetRequiredService<TimeProvider>();
+        var logger = serviceProvider.GetRequiredService<ILoggerFactory>().CreateLogger<DnsResolver>();
+        return new DnsResolver(timeProvider, logger, resolverOptions);
+    }
+
     public ValueTask<ServiceResult[]> ResolveServiceAsync(string name, CancellationToken cancellationToken = default)
     {
         ObjectDisposedException.ThrowIf(_disposed, this);

src/Libraries/Microsoft.Extensions.ServiceDiscovery.Dns/Resolver/NetworkInfo.cs

@@ -8,8 +8,8 @@ namespace Microsoft.Extensions.ServiceDiscovery.Dns.Resolver;
 
 internal static class NetworkInfo
 {
-    // basic option to get DNS serves via NetworkInfo. We may get it directly later via proper APIs.
-    public static ResolverOptions GetOptions()
+    // basic option to get DNS servers via NetworkInfo. We may get it directly later via proper APIs.
+    public static IList<IPEndPoint> GetServers()
     {
         List<IPEndPoint> servers = new List<IPEndPoint>();
 
@@ -31,6 +31,6 @@ public static ResolverOptions GetOptions()
             }
         }
 
-        return new ResolverOptions(servers);
+        return servers;
     }
 }

src/Libraries/Microsoft.Extensions.ServiceDiscovery.Dns/Resolver/ResolvConf.cs

@@ -10,12 +10,12 @@ internal static class ResolvConf
 {
     [SupportedOSPlatform("linux")]
     [SupportedOSPlatform("osx")]
-    public static ResolverOptions GetOptions()
+    public static IList<IPEndPoint> GetServers()
     {
-        return GetOptions(new StreamReader("/etc/resolv.conf"));
+        return GetServers(new StreamReader("/etc/resolv.conf"));
     }
 
-    public static ResolverOptions GetOptions(TextReader reader)
+    public static IList<IPEndPoint> GetServers(TextReader reader)
     {
         List<IPEndPoint> serverList = new();
 
@@ -40,9 +40,9 @@ public static ResolverOptions GetOptions(TextReader reader)
         if (serverList.Count == 0)
         {
             // If no nameservers are configured, fall back to the default behavior of using the system resolver configuration.
-            return NetworkInfo.GetOptions();
+            return NetworkInfo.GetServers();
         }
 
-        return new ResolverOptions(serverList);
+        return serverList;
     }
 }

src/Libraries/Microsoft.Extensions.ServiceDiscovery.Dns/Resolver/ResolverOptions.cs

@@ -5,27 +5,26 @@
 
 namespace Microsoft.Extensions.ServiceDiscovery.Dns.Resolver;
 
-internal sealed class ResolverOptions
+/// <summary>
+/// Provides configuration options for DNS resolution, including server endpoints, retry attempts, and timeout settings.
+/// </summary>
+public class ResolverOptions
 {
-    public IReadOnlyList<IPEndPoint> Servers;
-    public int Attempts = 2;
-    public TimeSpan Timeout = TimeSpan.FromSeconds(3);
+    /// <summary>
+    /// Gets or sets the collection of server endpoints used for network connections.
+    /// </summary>
+    public IList<IPEndPoint> Servers { get; set; } = new List<IPEndPoint>();
 
-    // override for testing purposes
-    internal Func<Memory<byte>, int, int>? _transportOverride;
-
-    public ResolverOptions(IReadOnlyList<IPEndPoint> servers)
-    {
-        if (servers.Count == 0)
-        {
-            throw new ArgumentException("At least one DNS server is required.", nameof(servers));
-        }
+    /// <summary>
+    /// Gets or sets the number of allowed attempts for the operation.
+    /// </summary>
+    public int Attempts { get; set; } = 2;
 
-        Servers = servers;
-    }
+    /// <summary>
+    /// Gets or sets the maximum duration to wait for an operation to complete before timing out.
+    /// </summary>
+    public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(3);
 
-    public ResolverOptions(IPEndPoint server)
-    {
-        Servers = new IPEndPoint[] { server };
-    }
+    // override for testing purposes
+    internal Func<Memory<byte>, int, int>? _transportOverride;
 }

src/Libraries/Microsoft.Extensions.ServiceDiscovery.Dns/ServiceDiscoveryDnsServiceCollectionExtensions.cs

@@ -3,6 +3,7 @@
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Options;
 using Microsoft.Extensions.ServiceDiscovery;
 using Microsoft.Extensions.ServiceDiscovery.Dns;
 using Microsoft.Extensions.ServiceDiscovery.Dns.Resolver;
@@ -49,7 +50,7 @@ public static IServiceCollection AddDnsSrvServiceEndpointProvider(this IServiceC
 
         if (!GetDnsClientFallbackFlag())
         {
-            services.TryAddSingleton<IDnsResolver, DnsResolver>();
+            services.TryAddSingleton<IDnsResolver>(DnsResolver.Create);
         }
         else
         {

test/Libraries/Microsoft.Extensions.ServiceDiscovery.Dns.Tests.Fuzzing/Fuzzers/DnsResponseFuzzer.cs

@@ -19,8 +19,9 @@ public void FuzzTarget(ReadOnlySpan<byte> data)
         if (_resolver == null)
         {
             _buffer = new byte[4096];
-            _resolver = new DnsResolver(new ResolverOptions(new IPEndPoint(IPAddress.Loopback, 53))
+            _resolver = new DnsResolver(new ResolverOptions
             {
+                Servers = [new IPEndPoint(IPAddress.Loopback, 53)],
                 Timeout = TimeSpan.FromSeconds(5),
                 Attempts = 1,
                 _transportOverride = (buffer, length) =>
@@ -41,4 +42,4 @@ public void FuzzTarget(ReadOnlySpan<byte> data)
         Debug.Assert(task.IsCompleted, "Task should be completed synchronously");
         task.GetAwaiter().GetResult();
     }
-}
+}

test/Libraries/Microsoft.Extensions.ServiceDiscovery.Dns.Tests/DnsServiceEndpointResolverTests.cs

@@ -17,7 +17,7 @@ public async Task ResolveServiceEndpoint_Dns_MultiShot()
         var timeProvider = new FakeTimeProvider();
         var services = new ServiceCollection()
             .AddSingleton<TimeProvider>(timeProvider)
-            .AddSingleton<IDnsResolver, DnsResolver>()
+            .AddSingleton<IDnsResolver>(DnsResolver.Create)
             .AddServiceDiscoveryCore()
             .AddDnsServiceEndpointProvider(o => o.DefaultRefreshPeriod = TimeSpan.FromSeconds(30))
             .BuildServiceProvider();

test/Libraries/Microsoft.Extensions.ServiceDiscovery.Dns.Tests/Resolver/LoopbackDnsTestBase.cs

@@ -26,8 +26,9 @@ public LoopbackDnsTestBase(ITestOutputHelper output)
         Output = output;
         DnsServer = new();
         TimeProvider = new();
-        Options = new([DnsServer.DnsEndPoint])
+        Options = new()
         {
+            Servers = [DnsServer.DnsEndPoint],
             Timeout = TimeSpan.FromSeconds(5),
             Attempts = 1,
         };