feat: add HTTP and file prefix providers with testing coverage

- Introduce `PrefixSourceProviderFactory` for dynamic provider resolution based on kind (e.g., file, http).
- Add `FilePrefixProvider` to read CIDR files and `HttpPrefixProvider` to fetch prefixes from HTTP URLs.
- Extend `AppConfig` with configurable prefix sources and default source name.
- Integrate prefix provider factory into `PrefixService` to replace old RU prefix loading logic.
- Add comprehensive unit tests for provider factory, file and HTTP providers, and prefix source service functionality.

Author: ruhex

BGPLite.Api/BGPLite.Api.csproj

@@ -12,6 +12,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\BGPLite.Configuration\BGPLite.Configuration.csproj" />
+    <ProjectReference Include="..\BGPLite.Providers\BGPLite.Providers.csproj" />
     <ProjectReference Include="..\BGPLite.Routing\BGPLite.Routing.csproj" />
     <ProjectReference Include="..\BGPLite.Server\BGPLite.Server.csproj" />
   </ItemGroup>

BGPLite.Api/ManagementApi.cs

@@ -5,6 +5,7 @@
 using BGPLite.Api.Entities;
 using BGPLite.Configuration;
 using BGPLite.Protocol;
+using BGPLite.Providers;
 using BGPLite.Routing;
 using BGPLite.Server;
 using Microsoft.Extensions.Hosting;
@@ -19,6 +20,7 @@ public sealed class ManagementApi : IHostedService, IDisposable
     private readonly AppConfig _config;
     private readonly BgpMetrics _metrics;
     private readonly IPrefixService? _prefixService;
+    private readonly IPrefixSourceService? _prefixSources;
     private readonly ISessionManager? _sessionManager;
     private readonly ILogger<ManagementApi> _logger;
     private readonly int _port;
@@ -33,13 +35,15 @@ public ManagementApi(
         BgpMetrics metrics,
         ILogger<ManagementApi> logger,
         IPrefixService? prefixService = null,
+        IPrefixSourceService? prefixSources = null,
         ISessionManager? sessionManager = null)
     {
         _store = store;
         _routeTable = routeTable;
         _config = config;
         _metrics = metrics;
         _prefixService = prefixService;
+        _prefixSources = prefixSources;
         _sessionManager = sessionManager;
         _logger = logger;
         _port = config.ApiPort;
@@ -267,7 +271,7 @@ private ApiResponse HandleGetMe(HttpListenerContext ctx)
                 lists = subscriptions,
                 customPrefixes,
                 customAsns,
-                communities = communities.Select(CommunityToString),
+                communities = communities.Select(CommunityCodec.Format),
                 allRoutes = communities.Count == 0
             }
         });
@@ -357,7 +361,7 @@ private ApiResponse HandleGetPeer(string peerId)
             lists = subscriptions,
             customPrefixes,
             customAsns,
-            communities = communities.Select(CommunityToString),
+            communities = communities.Select(CommunityCodec.Format),
             allRoutes = communities.Count == 0
         });
     }
@@ -521,6 +525,26 @@ private async Task<ApiResponse> HandleGetAsnListsAsync()
             });
         }
 
+        // Append configured PrefixSources (file/http) alongside the legacy RipeStat ASN-lists,
+        // reusing the same response shape. "Kind" is intentionally not exposed.
+        if (_prefixSources is not null)
+        {
+            var seen = lists.Select(l => l.Name).ToHashSet();
+            foreach (var (source, prefixes) in await _prefixSources.LoadAllAsync())
+            {
+                if (!seen.Add(source.Name)) continue; // skip names already present (e.g. shared "ru")
+                result.Add(new
+                {
+                    id = source.Name,
+                    Name = source.Name,
+                    Description = source.Description,
+                    Country = (string?)null,
+                    prefixCount = prefixes.Count,
+                    type = "list"
+                });
+            }
+        }
+
         return ApiResponse.Ok(result);
     }
 
@@ -548,7 +572,7 @@ private ApiResponse HandleGetRoutes()
                 ? [(community: 0u, route: r)]
                 : r.Communities.Select(c => (community: c, route: r)))
             .GroupBy(x => x.community)
-            .ToDictionary(g => g.Key == 0 ? "default" : CommunityToString(g.Key), g => g.Count());
+            .ToDictionary(g => g.Key == 0 ? "default" : CommunityCodec.Format(g.Key), g => g.Count());
 
         return ApiResponse.Ok(new { total = routes.Count, byCommunity });
     }
@@ -602,19 +626,6 @@ private static string GetClientIp(HttpListenerContext ctx)
         return ctx.Request.RemoteEndPoint?.Address.ToString() ?? "unknown";
     }
 
-    private static uint ParseCommunity(string community)
-    {
-        var colon = community.IndexOf(':');
-        var asn = uint.Parse(community[..colon]);
-        var value = uint.Parse(community[(colon + 1)..]);
-        return (asn << 16) | (value & 0xFFFF);
-    }
-
-    private static string CommunityToString(uint community)
-    {
-        return $"{community >> 16}:{community & 0xFFFF}";
-    }
-
     private static async Task WriteResponse(HttpListenerContext ctx, ApiResponse response)
     {
         ctx.Response.StatusCode = response.StatusCode;

BGPLite.Configuration/AppConfig.cs

@@ -15,4 +15,12 @@ public sealed class AppConfig
 
     [YamlMember(Alias = "RipeStat")]
     public RipeStatConfig? RipeStat { get; init; }
+
+    /// <summary>Configurable prefix sources (file, http, ...) loaded at startup via the provider factory.</summary>
+    [YamlMember(Alias = "PrefixSources")]
+    public List<PrefixSourceConfig> PrefixSources { get; init; } = [];
+
+    /// <summary>Name of the source served as the RU/default set for unconfigured peers.</summary>
+    [YamlMember(Alias = "DefaultPrefixSource")]
+    public string? DefaultPrefixSource { get; init; }
 }

BGPLite.Configuration/PrefixSourceConfig.cs

@@ -0,0 +1,40 @@
+using YamlDotNet.Serialization;
+
+namespace BGPLite.Configuration;
+
+/// <summary>
+/// A configurable prefix source. <see cref="Kind"/> selects the loader implementation
+/// via <c>PrefixSourceProviderFactory</c> (e.g. <c>"file"</c>, <c>"http"</c>).
+/// </summary>
+public sealed class PrefixSourceConfig
+{
+    /// <summary>Loader kind: <c>"file"</c> (reads <see cref="Path"/>) or <c>"http"</c> (fetches <see cref="Url"/>).</summary>
+    [YamlMember(Alias = "Kind")]
+    public string Kind { get; init; } = "file";
+
+    [YamlMember(Alias = "Name")]
+    public string Name { get; init; } = "";
+
+    [YamlMember(Alias = "Description")]
+    public string? Description { get; init; }
+
+    /// <summary>Optional community in <c>"ASN:VALUE"</c> form attached to every prefix from this source.</summary>
+    [YamlMember(Alias = "Community")]
+    public string? Community { get; init; }
+
+    /// <summary>Raw URL of a CIDR list (kind = <c>"http"</c>).</summary>
+    [YamlMember(Alias = "Url")]
+    public string? Url { get; init; }
+
+    /// <summary>Local file path, relative to <c>AppContext.BaseDirectory</c> (kind = <c>"file"</c>).</summary>
+    [YamlMember(Alias = "Path")]
+    public string? Path { get; init; }
+
+    /// <summary>Per-source HTTP timeout in seconds (kind = <c>"http"</c>). Overrides the default when set.</summary>
+    [YamlMember(Alias = "Timeout")]
+    public int? Timeout { get; init; }
+
+    /// <summary>Per-source HTTP request headers, e.g. <c>Authorization</c> / <c>X-API-Key</c> (kind = <c>"http"</c>).</summary>
+    [YamlMember(Alias = "Headers")]
+    public Dictionary<string, string>? Headers { get; init; }
+}

BGPLite.Protocol/CommunityCodec.cs

@@ -0,0 +1,25 @@
+namespace BGPLite.Protocol;
+
+/// <summary>
+/// Encodes/decodes a BGP well-known community between its <c>"ASN:VALUE"</c> string form
+/// and the packed 32-bit representation (<c>(asn &lt;&lt; 16) | value</c>) used across the codebase.
+/// </summary>
+public static class CommunityCodec
+{
+    public static uint Parse(string community)
+    {
+        var colon = community.IndexOf(':');
+        if (colon < 0)
+            throw new FormatException($"Invalid community '{community}' (expected 'ASN:VALUE').");
+
+        var asn = uint.Parse(community[..colon]);
+        var value = uint.Parse(community[(colon + 1)..]);
+
+        if (asn > 0xFFFF)
+            throw new FormatException($"Invalid community '{community}': ASN part must be 0-65535 (got {asn}).");
+
+        return (asn << 16) | (value & 0xFFFF);
+    }
+
+    public static string Format(uint community) => $"{community >> 16}:{community & 0xFFFF}";
+}

BGPLite.Providers/BGPLite.Providers.csproj

@@ -14,6 +14,8 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="9.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.0" />
   </ItemGroup>
 
 </Project>

BGPLite.Providers/FilePrefixProvider.cs

@@ -0,0 +1,28 @@
+using BGPLite.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace BGPLite.Providers;
+
+/// <summary>Loads prefixes from a local CIDR file (Kind = <c>"file"</c>).</summary>
+public sealed class FilePrefixProvider(ILogger<FilePrefixProvider> logger) : IPrefixSourceProvider
+{
+    public string Kind => "file";
+
+    public Task<IReadOnlyList<(uint Prefix, byte Length)>> LoadAsync(PrefixSourceConfig source, CancellationToken ct = default)
+    {
+        var path = source.Path;
+        if (string.IsNullOrWhiteSpace(path))
+            throw new InvalidOperationException($"Prefix source '{source.Name}': Kind=file requires a Path.");
+
+        var fullPath = Path.IsPathRooted(path)
+            ? path
+            : Path.Combine(AppContext.BaseDirectory, path);
+
+        if (!File.Exists(fullPath))
+            throw new FileNotFoundException($"Prefix file not found for source '{source.Name}': {fullPath}", fullPath);
+
+        var prefixes = PrefixListParser.Parse(File.ReadAllText(fullPath));
+        logger.LogInformation("Source '{Name}' (file): loaded {Count} prefixes from {Path}", source.Name, prefixes.Count, fullPath);
+        return Task.FromResult(prefixes);
+    }
+}

BGPLite.Providers/HttpPrefixProvider.cs

@@ -0,0 +1,47 @@
+using BGPLite.Configuration;
+using Microsoft.Extensions.Http;
+using Microsoft.Extensions.Logging;
+
+namespace BGPLite.Providers;
+
+/// <summary>
+/// Loads prefixes from a remote CIDR list over HTTP/HTTPS (Kind = <c>"http"</c>). Any direct
+/// raw-file URL works — raw.githubusercontent.com, a gist, a pastebin, a self-hosted list, etc.
+/// The URL is fetched as-is. Uses <see cref="IHttpClientFactory"/> so the handler pool is recycled
+/// by the factory (the provider is stateless and safe to hold as a singleton).
+/// </summary>
+public sealed class HttpPrefixProvider(IHttpClientFactory httpFactory, ILogger<HttpPrefixProvider> logger)
+    : IPrefixSourceProvider
+{
+    /// <summary>Named-client key registered with <c>IHttpClientFactory</c>.</summary>
+    public const string ClientName = "http";
+
+    public string Kind => "http";
+
+    public async Task<IReadOnlyList<(uint Prefix, byte Length)>> LoadAsync(PrefixSourceConfig source, CancellationToken ct = default)
+    {
+        if (string.IsNullOrWhiteSpace(source.Url))
+            throw new InvalidOperationException($"Prefix source '{source.Name}': Kind=http requires a Url.");
+
+        var url = source.Url;
+        var http = httpFactory.CreateClient(ClientName);
+        if (source.Timeout is int seconds && seconds > 0)
+            http.Timeout = TimeSpan.FromSeconds(seconds);
+        if (source.Headers is { Count: > 0 } headers)
+            foreach (var (key, value) in headers)
+            {
+                // A per-source User-Agent replaces the named-client default instead of appending a second value.
+                if (key.Equals("User-Agent", StringComparison.OrdinalIgnoreCase))
+                    http.DefaultRequestHeaders.Remove(key);
+                if (!http.DefaultRequestHeaders.TryAddWithoutValidation(key, value))
+                    logger.LogWarning("Source '{Name}': could not add request header '{Header}'.", source.Name, key);
+            }
+        using var response = await http.GetAsync(url, ct);
+        response.EnsureSuccessStatusCode();
+
+        var text = await response.Content.ReadAsStringAsync(ct);
+        var prefixes = PrefixListParser.Parse(text);
+        logger.LogInformation("Source '{Name}' (http): loaded {Count} prefixes from {Url}", source.Name, prefixes.Count, url);
+        return prefixes;
+    }
+}

BGPLite.Providers/IPrefixSourceProvider.cs

@@ -0,0 +1,18 @@
+using BGPLite.Configuration;
+
+namespace BGPLite.Providers;
+
+/// <summary>
+/// Loads a static prefix list from a single kind of source (file, HTTP raw URL, ...).
+/// Implementations are registered in DI and selected by <see cref="Kind"/> via
+/// <see cref="PrefixSourceProviderFactory"/>. Add a new loading method by implementing
+/// this interface and registering the implementation.
+/// </summary>
+public interface IPrefixSourceProvider
+{
+    /// <summary>Discriminator matched against <see cref="PrefixSourceConfig.Kind"/>.</summary>
+    string Kind { get; }
+
+    /// <summary>Fetch and parse the CIDR list described by <paramref name="source"/>.</summary>
+    Task<IReadOnlyList<(uint Prefix, byte Length)>> LoadAsync(PrefixSourceConfig source, CancellationToken ct = default);
+}

BGPLite.Providers/IPrefixSourceService.cs

@@ -0,0 +1,23 @@
+using BGPLite.Configuration;
+
+namespace BGPLite.Providers;
+
+/// <summary>
+/// Orchestrates configured <see cref="PrefixSourceConfig"/> entries: loads them through the
+/// provider factory, caches results in memory with a TTL, and resolves the designated default
+/// source used as the RU/fallback prefix set for unconfigured peers.
+/// </summary>
+public interface IPrefixSourceService
+{
+    /// <summary>All configured sources with their cached prefix lists.</summary>
+    Task<IReadOnlyList<(PrefixSourceConfig Source, IReadOnlyList<(uint Prefix, byte Length)> Prefixes)>> LoadAllAsync();
+
+    /// <summary>One source by name (cache-through). Empty list if missing or failed.</summary>
+    Task<IReadOnlyList<(uint Prefix, byte Length)>> GetAsync(string name);
+
+    /// <summary>The source named by <c>AppConfig.DefaultPrefixSource</c>. Empty list if unset/missing.</summary>
+    Task<IReadOnlyList<(uint Prefix, byte Length)>> GetDefaultAsync();
+
+    /// <summary>Prime the in-memory cache for all sources.</summary>
+    Task WarmUpAsync();
+}