108 lines
3.9 KiB
C#
108 lines
3.9 KiB
C#
using Microsoft.Extensions.Caching.Memory;
|
|
using Microsoft.Extensions.Options;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.NetworkInformation;
|
|
using System.Net.Sockets;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace FastGithub.DomainResolve
|
|
{
|
|
/// <summary>
|
|
/// IP状态服务
|
|
/// 状态缓存5分钟
|
|
/// 连接超时5秒
|
|
/// </summary>
|
|
sealed class IPAddressStatusService
|
|
{
|
|
private readonly TimeSpan brokeExpiration = TimeSpan.FromMinutes(1d);
|
|
private readonly TimeSpan normalExpiration = TimeSpan.FromMinutes(5d);
|
|
private readonly TimeSpan connectTimeout = TimeSpan.FromSeconds(5d);
|
|
private readonly IMemoryCache statusCache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
|
|
|
|
private readonly DnsClient dnsClient;
|
|
|
|
/// <summary>
|
|
/// IP状态服务
|
|
/// </summary>
|
|
/// <param name="dnsClient"></param>
|
|
public IPAddressStatusService(DnsClient dnsClient)
|
|
{
|
|
this.dnsClient = dnsClient;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 并行获取可连接的IP
|
|
/// </summary>
|
|
/// <param name="dnsEndPoint"></param>
|
|
/// <param name="cancellationToken"></param>
|
|
/// <returns></returns>
|
|
public async Task<IPAddress[]> GetAvailableAddressesAsync(DnsEndPoint dnsEndPoint, CancellationToken cancellationToken)
|
|
{
|
|
var addresses = new List<IPAddress>();
|
|
await foreach (var address in this.dnsClient.ResolveAsync(dnsEndPoint, fastSort: false, cancellationToken))
|
|
{
|
|
addresses.Add(address);
|
|
}
|
|
|
|
if (addresses.Count == 0)
|
|
{
|
|
return Array.Empty<IPAddress>();
|
|
}
|
|
|
|
var statusTasks = addresses.Select(address => this.GetStatusAsync(address, dnsEndPoint.Port, cancellationToken));
|
|
var statusArray = await Task.WhenAll(statusTasks);
|
|
return statusArray
|
|
.Where(item => item.Elapsed < TimeSpan.MaxValue)
|
|
.OrderBy(item => item.Elapsed)
|
|
.Select(item => item.Address)
|
|
.ToArray();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 获取IP状态
|
|
/// </summary>
|
|
/// <param name="address"></param>
|
|
/// <param name="port"></param>
|
|
/// <param name="cancellationToken"></param>
|
|
/// <returns></returns>
|
|
private async Task<IPAddressStatus> GetStatusAsync(IPAddress address, int port, CancellationToken cancellationToken)
|
|
{
|
|
var endPoint = new IPEndPoint(address, port);
|
|
if (this.statusCache.TryGetValue<IPAddressStatus>(endPoint, out var status))
|
|
{
|
|
return status;
|
|
}
|
|
|
|
var stopWatch = Stopwatch.StartNew();
|
|
try
|
|
{
|
|
using var timeoutTokenSource = new CancellationTokenSource(this.connectTimeout);
|
|
using var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutTokenSource.Token);
|
|
using var socket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
|
|
await socket.ConnectAsync(endPoint, linkedTokenSource.Token);
|
|
|
|
status = new IPAddressStatus(endPoint.Address, stopWatch.Elapsed);
|
|
return this.statusCache.Set(endPoint, status, this.normalExpiration);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
|
|
status = new IPAddressStatus(endPoint.Address, TimeSpan.MaxValue);
|
|
var expiration = NetworkInterface.GetIsNetworkAvailable() ? this.normalExpiration : this.brokeExpiration;
|
|
return this.statusCache.Set(endPoint, status, expiration);
|
|
}
|
|
finally
|
|
{
|
|
stopWatch.Stop();
|
|
}
|
|
}
|
|
}
|
|
}
|