Managed implementation of DNS resolver

playground/TestShop/TestShop.ServiceDefaults/Extensions.cs

@@ -21,6 +21,8 @@ public static TBuilder AddServiceDefaults<TBuilder>(this TBuilder builder) where
         builder.AddDefaultHealthChecks();
 
         builder.Services.AddServiceDiscovery();
+        // builder.Services.AddServiceDiscoveryCore();
+        // builder.Services.AddDnsSrvServiceEndpointProvider();
 
         builder.Services.ConfigureHttpClientDefaults(http =>
         {

src/Microsoft.Extensions.ServiceDiscovery.Dns/DnsServiceEndpointProvider.cs

@@ -4,6 +4,7 @@
 using System.Net;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using Microsoft.Extensions.ServiceDiscovery.Dns.Resolver;
 
 namespace Microsoft.Extensions.ServiceDiscovery.Dns;
 
@@ -12,6 +13,7 @@ internal sealed partial class DnsServiceEndpointProvider(
     string hostName,
     IOptionsMonitor<DnsServiceEndpointProviderOptions> options,
     ILogger<DnsServiceEndpointProvider> logger,
+    IDnsResolver resolver,
     TimeProvider timeProvider) : DnsServiceEndpointProviderBase(query, logger, timeProvider), IHostNameFeature
 {
     protected override double RetryBackOffFactor => options.CurrentValue.RetryBackOffFactor;
@@ -29,17 +31,14 @@ protected override async Task ResolveAsyncCore()
         var endpoints = new List<ServiceEndpoint>();
         var ttl = DefaultRefreshPeriod;
         Log.AddressQuery(logger, ServiceName, hostName);
-        var addresses = await System.Net.Dns.GetHostAddressesAsync(hostName, ShutdownToken).ConfigureAwait(false);
+
+        var now = _timeProvider.GetUtcNow().DateTime;
+        var addresses = await resolver.ResolveIPAddressesAsync(hostName, ShutdownToken).ConfigureAwait(false);
+
         foreach (var address in addresses)
         {
-            var serviceEndpoint = ServiceEndpoint.Create(new IPEndPoint(address, 0));
-            serviceEndpoint.Features.Set<IServiceEndpointProvider>(this);
-            if (options.CurrentValue.ShouldApplyHostNameMetadata(serviceEndpoint))
-            {
-                serviceEndpoint.Features.Set<IHostNameFeature>(this);
-            }
-
-            endpoints.Add(serviceEndpoint);
+            ttl = MinTtl(now, address.ExpiresAt, ttl);
+            endpoints.Add(CreateEndpoint(new IPEndPoint(address.Address, 0)));
         }
 
         if (endpoints.Count == 0)
@@ -48,5 +47,23 @@ protected override async Task ResolveAsyncCore()
         }
 
         SetResult(endpoints, ttl);
+
+        static TimeSpan MinTtl(DateTime now, DateTime expiresAt, TimeSpan existing)
+        {
+            var candidate = expiresAt - now;
+            return candidate < existing ? candidate : existing;
+        }
+
+        ServiceEndpoint CreateEndpoint(EndPoint endPoint)
+        {
+            var serviceEndpoint = ServiceEndpoint.Create(endPoint);
+            serviceEndpoint.Features.Set<IServiceEndpointProvider>(this);
+            if (options.CurrentValue.ShouldApplyHostNameMetadata(serviceEndpoint))
+            {
+                serviceEndpoint.Features.Set<IHostNameFeature>(this);
+            }
+
+            return serviceEndpoint;
+        }
     }
 }

src/Microsoft.Extensions.ServiceDiscovery.Dns/DnsServiceEndpointProviderBase.Log.cs

@@ -9,10 +9,10 @@ partial class DnsServiceEndpointProviderBase
 {
     internal static partial class Log
     {
-        [LoggerMessage(1, LogLevel.Trace, "Resolving endpoints for service '{ServiceName}' using DNS SRV lookup for name '{RecordName}'.", EventName = "SrvQuery")]
+        [LoggerMessage(1, LogLevel.Information, "Resolving endpoints for service '{ServiceName}' using DNS SRV lookup for name '{RecordName}'.", EventName = "SrvQuery")]
         public static partial void SrvQuery(ILogger logger, string serviceName, string recordName);
 
-        [LoggerMessage(2, LogLevel.Trace, "Resolving endpoints for service '{ServiceName}' using host lookup for name '{RecordName}'.", EventName = "AddressQuery")]
+        [LoggerMessage(2, LogLevel.Information, "Resolving endpoints for service '{ServiceName}' using host lookup for name '{RecordName}'.", EventName = "AddressQuery")]
         public static partial void AddressQuery(ILogger logger, string serviceName, string recordName);
 
         [LoggerMessage(3, LogLevel.Debug, "Skipping endpoint resolution for service '{ServiceName}': '{Reason}'.", EventName = "SkippedResolution")]

src/Microsoft.Extensions.ServiceDiscovery.Dns/DnsServiceEndpointProviderBase.cs

@@ -14,7 +14,7 @@ internal abstract partial class DnsServiceEndpointProviderBase : IServiceEndpoin
     private readonly object _lock = new();
     private readonly ILogger _logger;
     private readonly CancellationTokenSource _disposeCancellation = new();
-    private readonly TimeProvider _timeProvider;
+    protected readonly TimeProvider _timeProvider;
     private long _lastRefreshTimeStamp;
     private Task _resolveTask = Task.CompletedTask;
     private bool _hasEndpoints;

src/Microsoft.Extensions.ServiceDiscovery.Dns/DnsServiceEndpointProviderFactory.cs

@@ -4,18 +4,20 @@
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using Microsoft.Extensions.ServiceDiscovery.Dns.Resolver;
 
 namespace Microsoft.Extensions.ServiceDiscovery.Dns;
 
 internal sealed partial class DnsServiceEndpointProviderFactory(
     IOptionsMonitor<DnsServiceEndpointProviderOptions> options,
     ILogger<DnsServiceEndpointProvider> logger,
+    IDnsResolver resolver,
     TimeProvider timeProvider) : IServiceEndpointProviderFactory
 {
     /// <inheritdoc/>
     public bool TryCreateProvider(ServiceEndpointQuery query, [NotNullWhen(true)] out IServiceEndpointProvider? provider)
     {
-        provider = new DnsServiceEndpointProvider(query, hostName: query.ServiceName, options, logger, timeProvider);
+        provider = new DnsServiceEndpointProvider(query, hostName: query.ServiceName, options, logger, resolver, timeProvider);
         return true;
     }
 }

src/Microsoft.Extensions.ServiceDiscovery.Dns/DnsSrvServiceEndpointProvider.cs

@@ -2,10 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Net;
-using DnsClient;
-using DnsClient.Protocol;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using Microsoft.Extensions.ServiceDiscovery.Dns.Resolver;
 
 namespace Microsoft.Extensions.ServiceDiscovery.Dns;
 
@@ -15,7 +14,7 @@ internal sealed partial class DnsSrvServiceEndpointProvider(
     string hostName,
     IOptionsMonitor<DnsSrvServiceEndpointProviderOptions> options,
     ILogger<DnsSrvServiceEndpointProvider> logger,
-    IDnsQuery dnsClient,
+    IDnsResolver resolver,
     TimeProvider timeProvider) : DnsServiceEndpointProviderBase(query, logger, timeProvider), IHostNameFeature
 {
     protected override double RetryBackOffFactor => options.CurrentValue.RetryBackOffFactor;
@@ -35,56 +34,39 @@ protected override async Task ResolveAsyncCore()
         var endpoints = new List<ServiceEndpoint>();
         var ttl = DefaultRefreshPeriod;
         Log.SrvQuery(logger, ServiceName, srvQuery);
-        var result = await dnsClient.QueryAsync(srvQuery, QueryType.SRV, cancellationToken: ShutdownToken).ConfigureAwait(false);
-        if (result.HasError)
-        {
-            throw CreateException(srvQuery, result.ErrorMessage);
-        }
+        logger.LogInformation("Resolving endpoints for service '{ServiceName}' using DNS SRV lookup for name '{RecordName}'.", ServiceName, srvQuery);
 
-        var lookupMapping = new Dictionary<string, DnsResourceRecord>();
-        foreach (var record in result.Additionals.Where(x => x is AddressRecord or CNameRecord))
-        {
-            ttl = MinTtl(record, ttl);
-            lookupMapping[record.DomainName] = record;
-        }
+        var now = _timeProvider.GetUtcNow().DateTime;
+        var result = await resolver.ResolveServiceAsync(srvQuery, cancellationToken: ShutdownToken).ConfigureAwait(false);
+
+        logger.LogInformation("Resolved {Number} entries", result.Length);
 
-        var srvRecords = result.Answers.OfType<SrvRecord>();
-        foreach (var record in srvRecords)
+        foreach (var record in result)
         {
-            if (!lookupMapping.TryGetValue(record.Target, out var targetRecord))
-            {
-                continue;
-            }
+            ttl = MinTtl(now, record.ExpiresAt, ttl);
 
-            ttl = MinTtl(record, ttl);
-            if (targetRecord is AddressRecord addressRecord)
+            if (record.Addresses.Length > 0)
             {
-                endpoints.Add(CreateEndpoint(new IPEndPoint(addressRecord.Address, record.Port)));
+                foreach (var address in record.Addresses)
+                {
+                    ttl = MinTtl(now, address.ExpiresAt, ttl);
+                    endpoints.Add(CreateEndpoint(new IPEndPoint(address.Address, record.Port)));
+                }
             }
-            else if (targetRecord is CNameRecord canonicalNameRecord)
+            else
             {
-                endpoints.Add(CreateEndpoint(new DnsEndPoint(canonicalNameRecord.CanonicalName.Value.TrimEnd('.'), record.Port)));
+                endpoints.Add(CreateEndpoint(new DnsEndPoint(record.Target.TrimEnd('.'), record.Port)));
             }
         }
 
         SetResult(endpoints, ttl);
 
-        static TimeSpan MinTtl(DnsResourceRecord record, TimeSpan existing)
+        static TimeSpan MinTtl(DateTime now, DateTime expiresAt, TimeSpan existing)
         {
-            var candidate = TimeSpan.FromSeconds(record.TimeToLive);
+            var candidate = expiresAt - now;
             return candidate < existing ? candidate : existing;
         }
 
-        InvalidOperationException CreateException(string dnsName, string errorMessage)
-        {
-            var msg = errorMessage switch
-            {
-                { Length: > 0 } => $"No DNS records were found for service '{ServiceName}' (DNS name: '{dnsName}'): {errorMessage}.",
-                _ => $"No DNS records were found for service '{ServiceName}' (DNS name: '{dnsName}')."
-            };
-            return new InvalidOperationException(msg);
-        }
-
         ServiceEndpoint CreateEndpoint(EndPoint endPoint)
         {
             var serviceEndpoint = ServiceEndpoint.Create(endPoint);

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

@@ -2,29 +2,29 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics.CodeAnalysis;
-using DnsClient;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using Microsoft.Extensions.ServiceDiscovery.Dns.Resolver;
 
 namespace Microsoft.Extensions.ServiceDiscovery.Dns;
 
 internal sealed partial class DnsSrvServiceEndpointProviderFactory(
     IOptionsMonitor<DnsSrvServiceEndpointProviderOptions> options,
     ILogger<DnsSrvServiceEndpointProvider> logger,
-    IDnsQuery dnsClient,
+    IDnsResolver resolver,
     TimeProvider timeProvider) : IServiceEndpointProviderFactory
 {
     private static readonly string s_serviceAccountPath = Path.Combine($"{Path.DirectorySeparatorChar}var", "run", "secrets", "kubernetes.io", "serviceaccount");
     private static readonly string s_serviceAccountNamespacePath = Path.Combine($"{Path.DirectorySeparatorChar}var", "run", "secrets", "kubernetes.io", "serviceaccount", "namespace");
     private static readonly string s_resolveConfPath = Path.Combine($"{Path.DirectorySeparatorChar}etc", "resolv.conf");
-    private readonly string? _querySuffix = options.CurrentValue.QuerySuffix ?? GetKubernetesHostDomain();
+    private readonly string? _querySuffix = options.CurrentValue.QuerySuffix?.TrimStart('.') ?? GetKubernetesHostDomain();
 
     /// <inheritdoc/>
     public bool TryCreateProvider(ServiceEndpointQuery query, [NotNullWhen(true)] out IServiceEndpointProvider? provider)
     {
         // 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. 
+        // SRV records are available for headless services with named ports.
         // They take the form $"_{portName}._{protocol}.{serviceName}.{namespace}.{suffix}"
         // The suffix (after the service name) can be parsed from /etc/resolv.conf
         // Otherwise, the namespace can be read from /var/run/secrets/kubernetes.io/serviceaccount/namespace and combined with an assumed suffix of "svc.cluster.local".
@@ -39,7 +39,7 @@ public bool TryCreateProvider(ServiceEndpointQuery query, [NotNullWhen(true)] ou
 
         var portName = query.EndpointName ?? "default";
         var srvQuery = $"_{portName}._tcp.{query.ServiceName}.{_querySuffix}";
-        provider = new DnsSrvServiceEndpointProvider(query, srvQuery, hostName: query.ServiceName, options, logger, dnsClient, timeProvider);
+        provider = new DnsSrvServiceEndpointProvider(query, srvQuery, hostName: query.ServiceName, options, logger, resolver, timeProvider);
         return true;
     }
 

src/Microsoft.Extensions.ServiceDiscovery.Dns/Microsoft.Extensions.ServiceDiscovery.Dns.csproj

@@ -13,7 +13,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="DnsClient" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Options" />
@@ -27,7 +26,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <InternalsVisibleTo Include="Microsoft.Extensions.ServiceDiscovery.Dns.Tests"/>
+    <InternalsVisibleTo Include="Microsoft.Extensions.ServiceDiscovery.Dns.Tests" />
+    <InternalsVisibleTo Include="Microsoft.Extensions.ServiceDiscovery.Yarp.Tests" />
   </ItemGroup>
 
 </Project>

src/Microsoft.Extensions.ServiceDiscovery.Dns/Resolver/DnsDataReader.cs

@@ -0,0 +1,120 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Extensions.ServiceDiscovery.Dns.Resolver;
+
+internal struct DnsDataReader : IDisposable
+{
+    public byte[]? RawData { get; private set; }
+    private ReadOnlyMemory<byte> _buffer;
+    private int _position;
+
+    public DnsDataReader(ReadOnlyMemory<byte> buffer, byte[]? returnToPool = null)
+    {
+        _buffer = buffer;
+        _position = 0;
+        RawData = returnToPool;
+    }
+
+    public bool TryReadHeader(out DnsMessageHeader header)
+    {
+        if (_buffer.Length - _position < DnsMessageHeader.HeaderLength)
+        {
+            header = default;
+            return false;
+        }
+
+        _position += DnsMessageHeader.HeaderLength;
+        header = MemoryMarshal.AsRef<DnsMessageHeader>(_buffer.Span);
+        return true;
+    }
+
+    internal bool TryReadQuestion([NotNullWhen(true)] out string? name, out QueryType type, out QueryClass @class)
+    {
+        if (!TryReadDomainName(out name) ||
+            !TryReadUInt16(out ushort typeAsInt) ||
+            !TryReadUInt16(out ushort classAsInt))
+        {
+            type = 0;
+            @class = 0;
+            return false;
+        }
+
+        type = (QueryType)typeAsInt;
+        @class = (QueryClass)classAsInt;
+        return true;
+    }
+
+    public bool TryReadUInt16(out ushort value)
+    {
+        if (_buffer.Length - _position < 2)
+        {
+            value = 0;
+            return false;
+        }
+
+        value = BinaryPrimitives.ReadUInt16BigEndian(_buffer.Span.Slice(_position));
+        _position += 2;
+        return true;
+    }
+
+    public bool TryReadUInt32(out uint value)
+    {
+        if (_buffer.Length - _position < 4)
+        {
+            value = 0;
+            return false;
+        }
+
+        value = BinaryPrimitives.ReadUInt32BigEndian(_buffer.Span.Slice(_position));
+        _position += 4;
+        return true;
+    }
+
+    public bool TryReadResourceRecord(out DnsResourceRecord record)
+    {
+        if (!TryReadDomainName(out string? name) ||
+            !TryReadUInt16(out ushort type) ||
+            !TryReadUInt16(out ushort @class) ||
+            !TryReadUInt32(out uint ttl) ||
+            !TryReadUInt16(out ushort dataLength) ||
+            _buffer.Length - _position < dataLength)
+        {
+            record = default;
+            return false;
+        }
+
+        ReadOnlyMemory<byte> data = _buffer.Slice(_position, dataLength);
+        _position += dataLength;
+
+        record = new DnsResourceRecord(name, (QueryType)type, (QueryClass)@class, (int)ttl, data);
+        return true;
+    }
+
+    public bool TryReadDomainName([NotNullWhen(true)] out string? name)
+    {
+        if (DnsPrimitives.TryReadQName(_buffer.Span, _position, out name, out int bytesRead))
+        {
+            _position += bytesRead;
+            return true;
+        }
+
+        return false;
+    }
+
+    public void Dispose()
+    {
+        if (RawData is not null)
+        {
+            ArrayPool<byte>.Shared.Return(RawData);
+            RawData = null!;
+        }
+
+        _buffer = default;
+    }
+}