Add proxy provider implementations

WebReaper/Extensions/EnumerableExtensions.cs

@@ -0,0 +1,66 @@
+using System;
+
+namespace WebReaper.Extensions;
+
+internal static class EnumerableExtensions
+{
+    public static IEnumerable<U> SelectTruthy<T, U>(this IEnumerable<T> enumerable, Func<T, U?> predicate)
+        where U : class
+    {
+        foreach (var item in enumerable)
+        {
+            if (predicate(item) is { } result)
+            {
+                yield return result;
+            }
+        }
+    }
+
+    public static IEnumerable<T> SelectTruthy<T>(this IEnumerable<T?> enumerable)
+    {
+        foreach (var item in enumerable)
+        {
+            if (item is { } result)
+            {
+                yield return result;
+            }
+        }
+    }
+
+    public static IEnumerable<U> SelectTruthy<T, U>(this IEnumerable<T> enumerable, Func<T, U?> predicate) where U : struct
+    {
+        foreach (var item in enumerable)
+        {
+            if (predicate(item) is { } result)
+            {
+                yield return result;
+            }
+        }
+    }
+
+    public static IEnumerable<T> SelectTruthy<T>(this IEnumerable<T?> enumerable) where T : struct
+    {
+        foreach (var item in enumerable)
+        {
+            if (item is { } result)
+            {
+                yield return result;
+            }
+        }
+    }
+
+    public static T ChooseRandom<T>(this IEnumerable<T> enumerable, Random? random = null)
+    {
+        random ??= Random.Shared;
+        if (enumerable.TryGetNonEnumeratedCount(out var count))
+        {
+            var index = random.Next(count);
+            return enumerable.ElementAt(index);
+        }
+        else
+        {
+            var list = enumerable.ToList();
+            return list[random.Next(list.Count)];
+        }
+    }
+}

WebReaper/Proxy/Abstract/IProxyProposalProvider.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Net;
+
+namespace WebReaper.Proxy.Abstract;
+
+/// <summary>
+/// Supplies a list of unvalidated proxies.
+/// </summary>
+public interface IProxyProposalProvider
+{
+    /// <summary>
+    /// Returns a list of potential proxies, which may or may not be valid.
+    /// </summary>
+    Task<IEnumerable<WebProxy>> GetProxiesAsync(CancellationToken cancellationToken = default);
+}

WebReaper/Proxy/Abstract/IProxyProposalValidator.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Net;
+using WebReaper.Proxy.Concrete;
+
+namespace WebReaper.Proxy.Abstract;
+
+/// <summary>
+/// Validates a proposed proxy.
+/// </summary>
+public interface IProxyProposalValidator
+{
+    /// <summary>
+    /// Validates a proposed proxy.
+    /// </summary>
+    /// <returns>A <see cref="ProxyProposalValidationResult"/> indicating whether the proxy is valid or invalid, or the validator does not apply to the result.</returns>
+    Task<ProxyProposalValidationResult> ValidateAsync(WebProxy proxy, CancellationToken cancellationToken = default);
+}

WebReaper/Proxy/Abstract/IProxyProvider.cs

@@ -2,7 +2,13 @@
 
 namespace WebReaper.Proxy.Abstract;
 
+/// <summary>
+/// Provides a validated proxy.
+/// </summary>
 public interface IProxyProvider
 {
+    /// <summary>
+    /// Returns a validated proxy.
+    /// </summary>
     Task<WebProxy> GetProxyAsync();
 }

WebReaper/Proxy/Abstract/IValidatedProxyListProvider.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Net;
+
+namespace WebReaper.Proxy.Abstract;
+
+/// <summary>
+/// Supplies a list of validated, ready to use proxies.
+/// </summary>
+public interface IValidatedProxyListProvider
+{
+    /// <summary>
+    /// Returns a list of validated proxies.
+    /// </summary>
+    Task<IEnumerable<WebProxy>> GetProxiesAsync(CancellationToken cancellationToken = default);
+}

WebReaper/Proxy/Concrete/PingTimeoutProxyProposalValidator.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Net;
+using Microsoft.Extensions.Options;
+using WebReaper.Proxy.Abstract;
+
+namespace WebReaper.Proxy.Concrete;
+
+/// <summary>
+/// Options for <see cref="PingTimeoutProxyProposalValidator"/>.
+/// </summary>
+public sealed class PingTimeoutValidatorOptions : IOptions<PingTimeoutValidatorOptions>
+{
+    /// <summary>
+    /// The URL to visit to validate the proxy.
+    /// </summary>
+    public Uri ProbeUrl { get; set; } = new("https://www.cloudflare.com/");
+    /// <summary>
+    /// The maximum time to wait for a response from the probe URL.
+    /// </summary>
+    public TimeSpan ProbeTimeout { get; set; } = TimeSpan.FromSeconds(5);
+    PingTimeoutValidatorOptions IOptions<PingTimeoutValidatorOptions>.Value => this;
+}
+
+/// <summary>
+/// Validates a proxy by requesting a URL and waiting for a response.
+/// </summary>
+public sealed class PingTimeoutProxyProposalValidator : IProxyProposalValidator
+{
+    private readonly PingTimeoutValidatorOptions _options;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PingTimeoutProxyProposalValidator"/> class.
+    /// </summary>
+    public PingTimeoutProxyProposalValidator(IOptions<PingTimeoutValidatorOptions> options)
+    {
+        _options = options.Value;
+    }
+    /// <inheritdoc/>
+
+    public async Task<ProxyProposalValidationResult> ValidateAsync(WebProxy proxy, CancellationToken cancellationToken = default)
+    {
+        using HttpMessageHandler h = new HttpClientHandler
+        {
+            Proxy = proxy,
+            UseProxy = true
+        };
+        using var client = new HttpClient(h, false)
+        {
+            Timeout = _options.ProbeTimeout
+        };
+        try
+        {
+            var response = await client.GetAsync(_options.ProbeUrl, cancellationToken);
+            response.EnsureSuccessStatusCode();
+            return ProxyProposalValidationResult.Valid();
+        }
+        catch (AggregateException ex)
+        {
+            if (ex.InnerExceptions.All(ex => ex is OperationCanceledException))
+            {
+                return default;
+            }
+            return ProxyProposalValidationResult.Invalid(ex);
+        }
+        catch (OperationCanceledException)
+        {
+            return default;
+        }
+        catch (Exception ex)
+        {
+            return ProxyProposalValidationResult.Invalid(ex);
+        }
+    }
+}