< Summary

Information
Class: IceRpc.Locator.Internal.LocationResolver
Assembly: IceRpc.Locator
File(s): /home/runner/work/icerpc-csharp/icerpc-csharp/src/IceRpc.Locator/Internal/LocationResolver.cs
Tag: 275_13775359185
Line coverage
92%
Covered lines: 52
Uncovered lines: 4
Coverable lines: 56
Total lines: 193
Line coverage: 92.8%
Branch coverage
100%
Covered branches: 22
Total branches: 22
Branch coverage: 100%
Method coverage
100%
Covered methods: 3
Total methods: 3
Method coverage: 100%

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
ResolveAsync(...)100%11100%
PerformResolveAsync()100%22.422290.47%

File(s)

/home/runner/work/icerpc-csharp/icerpc-csharp/src/IceRpc.Locator/Internal/LocationResolver.cs

#LineLine coverage
 1// Copyright (c) ZeroC, Inc.
 2
 3using Microsoft.Extensions.Logging;
 4
 5namespace IceRpc.Locator.Internal;
 6
 7/// <summary>Provides extension methods for <see cref="ILogger" />. They are used by <see
 8/// cref="LogLocationResolverDecorator"/>.</summary>
 9internal static partial class LocatorLoggerExtensions
 10{
 11    [LoggerMessage(
 12        EventId = (int)LocationEventId.Resolved,
 13        EventName = nameof(LocationEventId.Resolved),
 14        Level = LogLevel.Debug,
 15        Message = "Resolved {LocationKind} '{Location}' = '{ServiceAddress}'")]
 16    internal static partial void LogResolved(
 17        this ILogger logger,
 18        string locationKind,
 19        Location location,
 20        ServiceAddress serviceAddress);
 21
 22    [LoggerMessage(
 23        EventId = (int)LocationEventId.FailedToResolve,
 24        EventName = nameof(LocationEventId.FailedToResolve),
 25        Level = LogLevel.Debug,
 26        Message = "Failed to resolve {LocationKind} '{Location}'")]
 27    internal static partial void LogFailedToResolve(
 28        this ILogger logger,
 29        string locationKind,
 30        Location location,
 31        Exception? exception = null);
 32}
 33
 34/// <summary>An implementation of <see cref="ILocationResolver" /> without a cache.</summary>
 35internal class CacheLessLocationResolver : ILocationResolver
 36{
 37    private readonly IServerAddressFinder _serverAddressFinder;
 38
 39    internal CacheLessLocationResolver(IServerAddressFinder serverAddressFinder) =>
 40        _serverAddressFinder = serverAddressFinder;
 41
 42    public ValueTask<(ServiceAddress? ServiceAddress, bool FromCache)> ResolveAsync(
 43        Location location,
 44        bool refreshCache,
 45        CancellationToken cancellationToken) => ResolveAsync(location, cancellationToken);
 46
 47    private async ValueTask<(ServiceAddress? ServiceAddress, bool FromCache)> ResolveAsync(
 48        Location location,
 49        CancellationToken cancellationToken)
 50    {
 51        ServiceAddress? serviceAddress = await _serverAddressFinder.FindAsync(location, cancellationToken)
 52            .ConfigureAwait(false);
 53
 54        // A well-known service address resolution can return a service address with an adapter ID
 55        if (serviceAddress is not null && serviceAddress.Params.TryGetValue("adapter-id", out string? adapterId))
 56        {
 57            (serviceAddress, _) = await ResolveAsync(
 58                new Location { IsAdapterId = true, Value = adapterId },
 59                cancellationToken).ConfigureAwait(false);
 60        }
 61
 62        return (serviceAddress, false);
 63    }
 64}
 65
 66/// <summary>The main implementation of <see cref="ILocationResolver" />, with a cache.</summary>
 67internal class LocationResolver : ILocationResolver
 68{
 69    private readonly bool _background;
 70    private readonly IServerAddressCache _serverAddressCache;
 71    private readonly IServerAddressFinder _serverAddressFinder;
 72    private readonly TimeSpan _refreshThreshold;
 73
 74    private readonly TimeSpan _ttl;
 75
 876    internal LocationResolver(
 877        IServerAddressFinder serverAddressFinder,
 878        IServerAddressCache serverAddressCache,
 879        bool background,
 880        TimeSpan refreshThreshold,
 881        TimeSpan ttl)
 882    {
 883        _serverAddressFinder = serverAddressFinder;
 884        _serverAddressCache = serverAddressCache;
 885        _background = background;
 886        _refreshThreshold = refreshThreshold;
 887        _ttl = ttl;
 888    }
 89
 90    public ValueTask<(ServiceAddress? ServiceAddress, bool FromCache)> ResolveAsync(
 91        Location location,
 92        bool refreshCache,
 993        CancellationToken cancellationToken) => PerformResolveAsync(location, refreshCache, cancellationToken);
 94
 95    private async ValueTask<(ServiceAddress? ServiceAddress, bool FromCache)> PerformResolveAsync(
 96        Location location,
 97        bool refreshCache,
 98        CancellationToken cancellationToken)
 1199    {
 11100        ServiceAddress? serviceAddress = null;
 11101        bool expired = false;
 11102        bool justRefreshed = false;
 11103        bool resolved = false;
 104
 11105        if (_serverAddressCache.TryGetValue(location, out (TimeSpan InsertionTime, ServiceAddress ServiceAddress) entry)
 7106        {
 7107            serviceAddress = entry.ServiceAddress;
 7108            TimeSpan cacheEntryAge = TimeSpan.FromMilliseconds(Environment.TickCount64) - entry.InsertionTime;
 7109            expired = _ttl != Timeout.InfiniteTimeSpan && cacheEntryAge > _ttl;
 7110            justRefreshed = cacheEntryAge <= _refreshThreshold;
 7111        }
 112
 11113        if (serviceAddress is null || (!_background && expired) || (refreshCache && !justRefreshed))
 6114        {
 6115            serviceAddress = await _serverAddressFinder.FindAsync(location, cancellationToken).ConfigureAwait(false);
 6116            resolved = true;
 6117        }
 5118        else if (_background && expired)
 1119        {
 120            // We retrieved an expired service address from the cache, so we launch a refresh in the background.
 1121            _ = _serverAddressFinder.FindAsync(location, cancellationToken: default).ConfigureAwait(false);
 1122        }
 123
 124        // A well-known service address resolution can return a service address with an adapter-id.
 11125        if (serviceAddress is not null && serviceAddress.Params.TryGetValue("adapter-id", out string? adapterId))
 2126        {
 127            try
 2128            {
 129                // Resolves adapter ID recursively, by checking first the cache. If we resolved the well-known
 130                // service address, we request a cache refresh for the adapter ID.
 2131                (serviceAddress, _) = await PerformResolveAsync(
 2132                    new Location { IsAdapterId = true, Value = adapterId },
 2133                    refreshCache || resolved,
 2134                    cancellationToken).ConfigureAwait(false);
 2135            }
 0136            catch
 0137            {
 0138                serviceAddress = null;
 0139                throw;
 140            }
 141            finally
 2142            {
 143                // When the second resolution fails, we clear the cache entry for the initial successful
 144                // resolution, since the overall resolution is a failure.
 2145                if (serviceAddress is null)
 1146                {
 1147                    _serverAddressCache.Remove(location);
 1148                }
 2149            }
 2150        }
 151
 11152        return (serviceAddress, serviceAddress is not null && !resolved);
 11153    }
 154}
 155
 156/// <summary>A decorator that adds event source logging to a location resolver.</summary>
 157internal class LogLocationResolverDecorator : ILocationResolver
 158{
 159    private readonly ILocationResolver _decoratee;
 160    private readonly ILogger _logger;
 161
 162    public async ValueTask<(ServiceAddress? ServiceAddress, bool FromCache)> ResolveAsync(
 163        Location location,
 164        bool refreshCache,
 165        CancellationToken cancellationToken)
 166    {
 167        try
 168        {
 169            (ServiceAddress? serviceAddress, bool fromCache) =
 170                await _decoratee.ResolveAsync(location, refreshCache, cancellationToken).ConfigureAwait(false);
 171            if (serviceAddress is not null)
 172            {
 173                _logger.LogResolved(location.Kind, location, serviceAddress);
 174            }
 175            else
 176            {
 177                _logger.LogFailedToResolve(location.Kind, location);
 178            }
 179            return (serviceAddress, fromCache);
 180        }
 181        catch (Exception exception)
 182        {
 183            _logger.LogFailedToResolve(location.Kind, location, exception);
 184            throw;
 185        }
 186    }
 187
 188    internal LogLocationResolverDecorator(ILocationResolver decoratee, ILogger logger)
 189    {
 190        _decoratee = decoratee;
 191        _logger = logger;
 192    }
 193}
Generated by: ReportGenerator 5.3.8.0
03/10/2025 - 21:46:44
GitHub | reportgenerator.io

Methods/Properties

.ctor(IceRpc.Locator.Internal.IServerAddressFinder,IceRpc.Locator.Internal.IServerAddressCache,System.Boolean,System.TimeSpan,System.TimeSpan)
ResolveAsync(IceRpc.Locator.Location,System.Boolean,System.Threading.CancellationToken)
PerformResolveAsync()