Update README

AS1024.GeoFeed.Core.GeoFeedLocalCache/AS1024.GeoFeed.Core.GeoFeedLocalCache.csproj

@@ -1,23 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-	<ItemGroup>
-		<PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.0" />
-		<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="8.0.0" />
-		<PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="8.0.0" />
-		<PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="8.0.0" />
-		<PackageReference Include="Microsoft.Extensions.Http" Version="8.0.0" />
-		<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" />
-	</ItemGroup>
-
-	<ItemGroup>
-	  <ProjectReference Include="..\AS1024.GeoFeed.Core\AS1024.GeoFeed.Core.csproj" />
-	  <ProjectReference Include="..\AS1024.GeoFeed.Models\AS1024.GeoFeed.Models.csproj" />
-	</ItemGroup>
-	
-</Project>

AS1024.GeoFeed.Core.GeoFeedLocalCache/GeoFeedSqliteLocalCache/GeoFeedCacheDbContext.cs

@@ -1,15 +0,0 @@
-using Microsoft.EntityFrameworkCore;
-
-namespace AS1024.GeoFeed.Core.GeoFeedSqliteLocalCache
-{
-    public class GeoFeedCacheDbContext : DbContext
-    {
-        public GeoFeedCacheDbContext(DbContextOptions options)
-            : base(options)
-        {
-        }
-
-        public virtual DbSet<GeoFeedCacheEntry> GeoFeedCacheEntries { get; set; }
-    }
-
-}

AS1024.GeoFeed.Core.GeoFeedLocalCache/GeoFeedSqliteLocalCache/GeoFeedCacheEntry.cs

@@ -1,12 +0,0 @@
-using AS1024.GeoFeed.Models;
-using System.ComponentModel.DataAnnotations;
-
-namespace AS1024.GeoFeed.Core.GeoFeedSqliteLocalCache
-{
-    public class GeoFeedCacheEntry : IPGeoFeed
-    {
-        [Key]
-        public int Id { get; set; }
-    }
-
-}

AS1024.GeoFeed.Core.GeoFeedLocalCache/GeoFeedSqliteLocalCache/GeoFeedCacheService.cs

@@ -1,58 +0,0 @@
-using AS1024.GeoFeed.Core.Interfaces;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using System.Runtime.CompilerServices;
-
-namespace AS1024.GeoFeed.Core.GeoFeedSqliteLocalCache
-{
-    public class GeoFeedCacheService : IHostedService
-    {
-        private readonly ILogger<GeoFeedCacheService> logger;
-        private readonly IGeoFeedProvider feedProvider;
-        private readonly IHost host;
-        private readonly IGeoFeedPersistentCacheProvider persistentCacheProvider;
-
-        public GeoFeedCacheService(ILogger<GeoFeedCacheService> logger,
-        IGeoFeedProvider feedProvider,
-        IHost host,
-        IGeoFeedPersistentCacheProvider persistentCacheProvider)
-        {
-            this.logger = logger;
-            this.feedProvider = feedProvider;
-            this.host = host;
-            this.persistentCacheProvider = persistentCacheProvider;
-        }
-
-        public Task StartAsync(CancellationToken cancellationToken)
-        {
-            _ = StartPerioidicSync(cancellationToken);
-            return Task.CompletedTask;
-        }
-
-        public Task StopAsync(CancellationToken cancellationToken)
-        {
-            return Task.CompletedTask;
-        }
-
-        public async Task<bool> StartPerioidicSync(CancellationToken Token)
-        {
-            while (!Token.IsCancellationRequested)
-            {
-                try
-                {
-                    var results = await feedProvider.GetGeoFeedData();
-                    await persistentCacheProvider.CacheGeoFeed(results);
-                }
-                catch (Exception)
-                {
-                    logger.LogWarning("On disk cache failed to run. Waiting on 30 minutes before retry...");
-                }
-                await Task.Delay(TimeSpan.FromMinutes(30));
-            }
-
-            return false;
-        }
-    }
-}

AS1024.GeoFeed.Core.GeoFeedLocalCache/GeoFeedSqliteLocalCache/GeoFeedDesignTimeMigration.cs

@@ -1,17 +0,0 @@
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Design;
-
-namespace AS1024.GeoFeed.Core.GeoFeedSqliteLocalCache
-
-{
-    public class GeoFeedDesignTimeMigration : IDesignTimeDbContextFactory<GeoFeedCacheDbContext>
-    {
-        public GeoFeedCacheDbContext CreateDbContext(string[] args)
-        {
-            var builder = new DbContextOptionsBuilder<GeoFeedCacheDbContext>();
-            builder.UseSqlite("Data Source=migratedb.db");
-            return new GeoFeedCacheDbContext(builder.Options);
-        }
-    }
-
-}

AS1024.GeoFeed.Core.GeoFeedLocalCache/GeoFeedSqliteLocalCache/GeoFeedSqliteCache.cs

@@ -1,72 +0,0 @@
-using AS1024.GeoFeed.Core.Interfaces;
-using AS1024.GeoFeed.Models;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Hosting;
-using AS1024.GeoFeed.Core.Tools;
-
-namespace AS1024.GeoFeed.Core.GeoFeedSqliteLocalCache
-{
-    public class GeoFeedSqliteCache : IGeoFeedPersistentCacheProvider
-    {
-        protected readonly GeoFeedCacheDbContext dbContext;
-        private readonly IGeoFeedProvider feedProvider;
-
-        public GeoFeedSqliteCache(GeoFeedCacheDbContext geoFeedCacheDb,
-                                  IHost host,
-                                  IGeoFeedProvider provider)
-        {
-            dbContext = geoFeedCacheDb;
-            feedProvider = provider;
-        }
-
-        public string ProviderName => "sqlite";
-
-        public async Task<bool> CacheGeoFeed(IList<IPGeoFeed> pGeoFeeds)
-        {
-            await DBContextMigrate();
-            List<GeoFeedCacheEntry> geoFeedCacheEntry = [];
-
-            var results = pGeoFeeds.ToList();
-
-            results.ForEach(x =>
-            {
-                geoFeedCacheEntry.Add(new()
-                {
-                    Prefix = x.Prefix,
-                    GeolocCity = x.GeolocCity,
-                    GeolocCountry = x.GeolocCountry,
-                    GeolocHasLocation = x.GeolocHasLocation,
-                    GeolocPostalCode = x.GeolocPostalCode,
-                    GeolocRegion = x.GeolocRegion
-                });
-            });
-
-            if (dbContext.GeoFeedCacheEntries.Any())
-            {
-                dbContext.GeoFeedCacheEntries.RemoveRange(dbContext.GeoFeedCacheEntries.ToArray());
-            }
-            await dbContext.AddRangeAsync(geoFeedCacheEntry);
-            await dbContext.SaveChangesAsync();
-
-            return true;
-        }
-
-        public string GetGeoFeed()
-        {
-            var results =
-                dbContext.GeoFeedCacheEntries.ToList();
-            List<IPGeoFeed> cachedData = [];
-            results.ForEach(cachedData.Add);
-
-            return cachedData.ToGeoFeedCsv();
-        }
-
-        private async Task DBContextMigrate()
-        {
-            if (dbContext.Database.GetPendingMigrations().Any())
-            {
-                await dbContext.Database.MigrateAsync();
-            }
-        }
-    }
-}

AS1024.GeoFeed.Core/GeoFeedProviders/NetBoxGeoFeedProviderBase.cs

@@ -9,7 +9,7 @@ using Microsoft.Extensions.Logging;
 
 namespace AS1024.GeoFeed.Core.GeoFeedProviders
 {
-    public class NetBoxGeoFeedProviderBase : IGeoFeedProvider
+    public abstract class NetBoxGeoFeedProviderBase : IGeoFeedProvider
     {
         protected readonly IConfiguration configuration;
         protected readonly ILogger<NetBoxGeoFeedProvider> logger;

AS1024.GeoFeed.MinimalAPI/AppJsonSerializerContext.cs

@@ -0,0 +1,15 @@
+using AS1024.GeoFeed.Models;
+using System.Text.Json.Serialization;
+
+namespace AS1024.GeoFeed.MinimalAPI
+{
+    [JsonSerializable(typeof(NetboxData))]
+    [JsonSerializable(typeof(Result))]
+    [JsonSerializable(typeof(CustomFields))]
+    [JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.SnakeCaseLower)]
+    internal partial class AppJsonSerializerContext : JsonSerializerContext
+    {
+
+    }
+
+}

AS1024.GeoFeed.MinimalAPI/Dockerfile

@@ -1,11 +1,11 @@
 #See https://aka.ms/customizecontainer to learn how to customize your debug container and how Visual Studio uses this Dockerfile to build your images for faster debugging.
 
-FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
+FROM mcr.microsoft.com/dotnet/runtime:8.0-jammy-chiseled AS base
 USER app
 WORKDIR /app
 EXPOSE 8080
 
-FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+FROM mcr.microsoft.com/dotnet/sdk:8.0-jammy AS build
 # Install clang/zlib1g-dev dependencies for publishing to native
 RUN apt-get update \
     && apt-get install -y --no-install-recommends \
@@ -20,9 +20,9 @@ RUN dotnet build "./AS1024.GeoFeed.MinimalAPI.csproj" -c $BUILD_CONFIGURATION -o
 
 FROM build AS publish
 ARG BUILD_CONFIGURATION=Release
-RUN dotnet publish "./AS1024.GeoFeed.MinimalAPI.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=true
+RUN dotnet publish "./AS1024.GeoFeed.MinimalAPI.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=true /p:DebugType=None /p:DebugSymbols=false
 
-FROM mcr.microsoft.com/dotnet/runtime-deps:8.0 AS final
+FROM base AS final
 WORKDIR /app
 EXPOSE 8080
 COPY --from=publish /app/publish .

AS1024.GeoFeed.MinimalAPI/Dockerfile.alpine-selfcontained

@@ -0,0 +1,55 @@
+#See https://aka.ms/customizecontainer to learn how to customize your debug container and how Visual Studio uses this Dockerfile to build your images for faster debugging.
+
+FROM alpine:latest AS base
+ENV \
+    # UID of the non-root user 'app'
+    APP_UID=1654 \
+    # Configure web servers to bind to port 8080 when present
+    ASPNETCORE_HTTP_PORTS=8080 \
+    # Enable detection of running in a container
+    DOTNET_RUNNING_IN_CONTAINER=true \
+    # Set the invariant mode since ICU package isn't included (see https://github.com/dotnet/announcements/issues/20)
+    DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=true
+
+#RUN apk add --upgrade --no-cache \
+#        ca-certificates-bundle \
+#        \
+#        # .NET dependencies
+#        libgcc \
+#        libssl3 \
+#        libstdc++ \
+#        zlib
+
+# Create a non-root user and group
+RUN addgroup \
+        --gid=$APP_UID \
+        app \
+    && adduser \
+        --uid=$APP_UID \
+        --ingroup=app \
+        --disabled-password \
+        app
+WORKDIR /app
+USER app
+EXPOSE 8080
+
+FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine AS build
+# Install clang/zlib1g-dev dependencies for publishing to native
+RUN apk add clang zlib-dev musl-dev libc6-compat
+ARG BUILD_CONFIGURATION=Release
+WORKDIR /src
+COPY ["AS1024.GeoFeed.MinimalAPI/AS1024.GeoFeed.MinimalAPI.csproj", "AS1024.GeoFeed.MinimalAPI/"]
+RUN dotnet restore "./AS1024.GeoFeed.MinimalAPI/./AS1024.GeoFeed.MinimalAPI.csproj"
+COPY . .
+WORKDIR "/src/AS1024.GeoFeed.MinimalAPI"
+RUN dotnet build "./AS1024.GeoFeed.MinimalAPI.csproj" -c $BUILD_CONFIGURATION -o /app/build
+
+FROM build AS publish
+ARG BUILD_CONFIGURATION=Release
+RUN dotnet publish "./AS1024.GeoFeed.MinimalAPI.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=true /p:DebugType=None /p:DebugSymbols=false
+
+FROM base AS final
+WORKDIR /app
+EXPOSE 8080
+COPY --from=publish /app/publish .
+ENTRYPOINT ["./AS1024.GeoFeed.MinimalAPI"]

AS1024.GeoFeed.MinimalAPI/GeoFeedAoTProvider.cs

@@ -1,21 +1,12 @@
 using AS1024.GeoFeed.Core.GeoFeedProviders;
 using AS1024.GeoFeed.Core.Interfaces;
 using AS1024.GeoFeed.Models;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
 using System.Text.Json;
-using System.Text.Json.Serialization.Metadata;
-using System.Threading.Tasks;
 
 namespace AS1024.GeoFeed.MinimalAPI
 {
     internal class NetboxAoTGeoFeedProvider : NetBoxGeoFeedProvider, IGeoFeedProvider
     {
-        private readonly JsonSerializerOptions appJsonSerializer;
-
         public NetboxAoTGeoFeedProvider(IConfiguration configuration,
                                         ILogger<NetBoxGeoFeedProvider> logger,
                                         IHttpClientFactory httpClientFactory)

AS1024.GeoFeed.MinimalAPI/Program.cs

@@ -1,19 +1,27 @@
+using AS1024.GeoFeed.Core.CacheService;
 using AS1024.GeoFeed.Core.GeoFeedProviders;
 using AS1024.GeoFeed.Core.Interfaces;
 using AS1024.GeoFeed.Core.Tools;
 using AS1024.GeoFeed.Models;
 using Microsoft.AspNetCore.Http.HttpResults;
 using Microsoft.AspNetCore.Mvc;
-using System.Text.Json.Serialization;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Text;
 
 namespace AS1024.GeoFeed.MinimalAPI
 {
     public class Program
     {
+
         public static void Main(string[] args)
         {
             var builder = WebApplication.CreateSlimBuilder(args);
             builder.Services.AddTransient<IGeoFeedProvider, NetboxAoTGeoFeedProvider>();
+            builder.Services.AddHostedService<GeoFeedCacheService>();
+            builder.Services.AddTransient<IGeoFeedPersistentCacheProvider, GeoFeedLocalFileCache>();
             builder.Services.AddMemoryCache();
             builder.Services.AddLogging();
             builder.Services.AddHttpClient();
@@ -21,31 +29,65 @@ namespace AS1024.GeoFeed.MinimalAPI
                 options.SerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonSerializerContext.Default);
             });
             var app = builder.Build();
-            var geoFeed = app.Map("/geofeed.csv", async (IGeoFeedProvider provider, ILogger<Program> logger) => {
-                try
-                {
-                    var results =
-                    await provider.GetGeoFeedData();
-                    return results.ToGeoFeedCsv();
-                }
-                catch (Exception ex)
-                {
-                    logger.LogError($"Error: {ex}");
-                }
 
-                return "";
+            app.Map("/geofeed.csv", async (IGeoFeedProvider provider, 
-            });
+                ILogger<Program> logger, 
+                IGeoFeedPersistentCacheProvider cacheProvider,
+                IMemoryCache memoryCache,
+                IWebHostEnvironment environment) => {
+                    return await GeoFeedDataRunner(provider, logger, cacheProvider, memoryCache, environment);
+                });
+
+            app.Map("/geofeed", async (IGeoFeedProvider provider,
+                ILogger<Program> logger,
+                IGeoFeedPersistentCacheProvider cacheProvider,
+                IMemoryCache memoryCache,
+                IWebHostEnvironment environment) => {
+                    return await GeoFeedDataRunner(provider, logger, cacheProvider, memoryCache, environment);
+                });
+
             app.Run();
         }
+
+        protected static async Task<IResult> GeoFeedDataRunner(IGeoFeedProvider provider,
+                ILogger<Program> logger,
+                IGeoFeedPersistentCacheProvider cacheProvider,
+                IMemoryCache memoryCache,
+                IWebHostEnvironment environment)
+        {
+            try
+            {
+                if (!memoryCache.TryGetValue("Geofeed", out List<IPGeoFeed>? feed))
+                {
+                    feed = await provider.GetGeoFeedData();
+                    if (environment.IsProduction())
+                    {
+                        MemoryCacheEntryOptions cacheEntryOptions = new MemoryCacheEntryOptions()
+                            .SetSlidingExpiration(TimeSpan.FromMinutes(15));
+                        memoryCache.Set("Geofeed", feed, cacheEntryOptions);
+                    }
+                }
+
+                return Results.File(Encoding.UTF8.GetBytes(feed.ToGeoFeedCsv()),
+                    "text/csv",
+                    "geofeed.csv");
+
+            }
+            catch (HttpRequestException ex)
+            {
+                logger.LogWarning($"Temporary failure of retrieving GeoData from upstream. {ex}");
+                string geoFeedData = cacheProvider.GetGeoFeed();
+
+                return Results.File(Encoding.UTF8.GetBytes(geoFeedData),
+                    "text/csv",
+                    "geofeed.csv");
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"Error: {ex}");
+            }
+
+            return Results.NoContent();
+        }
     }
-
-    [JsonSerializable(typeof(NetboxData))]
-    [JsonSerializable(typeof(Result))]
-    [JsonSerializable(typeof(CustomFields))]
-    [JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.SnakeCaseLower)]
-    internal partial class AppJsonSerializerContext : JsonSerializerContext
-    {
-
-    }
-
 }

README.md

@@ -6,23 +6,44 @@ This web application provides a self-published IP geolocation feed, conforming t
 
 The application is implemented in C# using .NET 8.0, ensuring a robust and modern back-end architecture. It's built to communicate securely over HTTPS with the NetBox API, adhering to best practices for data transmission and security. 
 
+This project was inspired by the GitHub project [GeoBox](https://github.com/FrumentumNL/GeoBox), which provided foundational ideas for the development of this application.
+
+## Application Variants
+
+### AS1024.GeoFeed - MVC Version (Recommended)
+
+The standard version of this application, named `AS1024.GeoFeed`, is built using the Model-View-Controller (MVC) architecture. This variant is fully supported and recommended for most use cases. It offers a complete set of features and is optimized for robustness and scalability.
+
+### AS1024.GeoFeed.MinimalAPI - MinimalAPI Version (Experimental)
+
+In addition to the standard MVC version, there is an experimental MinimalAPI version of the application named `AS1024.GeoFeed.MinimalAPI`. This variant is designed for environments that require extremely fast startup times, such as serverless containers. However, it comes with limited support and a reduced feature set. We recommend using the `AS1024.GeoFeed.MinimalAPI` version only if your deployment environment necessitates near-instant startup times and you are comfortable with its experimental nature and limitations.
+
+**Note**: While the `AS1024.GeoFeed.MinimalAPI` version offers performance benefits in specific scenarios, we strongly recommend deploying the `AS1024.GeoFeed` MVC version for most applications to ensure full functionality and support.
+
 ## Features
 
 - **GeoFeed Generation**: Dynamically generates a geolocation feed in CSV format as specified in RFC 8805.
 - **Caching Mechanism**: Implements an efficient caching strategy to reduce redundant API calls and enhance performance.
-- **Local Disk Fallback Caching Mechanism**: In the event of a failure to communicate with the NetBox instance specified, the web app will return data that is locally cached inside a SQLite database.
+- **Local Disk Fallback Caching Mechanism**: In the event of a failure to communicate with the NetBox instance specified, the web app will return data that is locally cached inside a SQLite database. In the minimal API version of the GeoFeed application, this will be stored as a file, rather than a SQLite database as Minimal API does not yet support Entity Framework Core at this time.
 - **Secure Communication**: Ensures secure data retrieval from NetBox over HTTPS.
 
 ## Configuration
 
-The application requires the following configuration variables to be set:
+The application requires the following configuration variables to be set, depending on the version you are using:
 
+### For AS1024.GeoFeed - MVC Version
 1. **APIKey**: This is the API key used for authenticating with the NetBox API. Ensure this key has the necessary permissions to access the required resources.
 2. **NetBoxHost**: The hostname of the NetBox instance from which the application retrieves data. For example, `netbox.example.com`.
-3. **LocalFeedCache**: This connection string is for a local SQLite Database that caches the geofeed data from Netbox.
+3. **LocalFeedCache**: This connection string is for a local SQLite Database (using EF Core) that caches the geofeed data from Netbox. The syntax should follow the standard SQLite EF Core connection string format.
+
+### For AS1024.GeoFeed.MinimalAPI - MinimalAPI Version
+1. **APIKey**: This is the API key used for authenticating with the NetBox API. Ensure this key has the necessary permissions to access the required resources.
+2. **NetBoxHost**: The hostname of the NetBox instance from which the application retrieves data. For example, `netbox.example.com`.
+3. **TempCache** (optional): This configuration is specific to the Minimal API version. It is optional, but if users wish to specify a different location for storing and serving the cached geofeed data, this value can be adjusted to point to the desired save location.
 
 These variables can be set in your application's configuration file or through environment variables, depending on your deployment strategy.
 
+
 ## NetBox Custom Fields
 
 Ensure that your NetBox instance is configured with the following custom fields:
@@ -46,6 +67,37 @@ To build and run the application, follow these steps:
 5. After a successful build, you can start the application by running `dotnet run`.
 6. The application will start, and you can access the endpoints as specified.
 
+## Building a Docker Image
+
+### Building a Docker Image for the Minimal API Version
+
+To containerize the `AS1024.GeoFeed` version using Docker, you can follow these steps to build a Docker image:
+
+1. Open your terminal or command line interface.
+2. Navigate to the root directory of this repository.
+3. Execute the following Docker build command: ``docker buildx build --platform=linux/amd64,linux/arm64 -f .\AS1024.GeoFeed\Dockerfile .``
+
+### Building a Docker Image for the Minimal API Version
+
+To containerize the `AS1024.GeoFeed.MinimalAPI` version using Docker, you can follow these steps to build a Docker image:
+
+1. Open your terminal or command line interface.
+2. Navigate to the root directory of this repository.
+3. Execute the following Docker build command: ``docker buildx build --platform=linux/amd64 -f .\AS1024.GeoFeed.MinimalAPI\Dockerfile.alpine-selfcontained .``
+
+**Currently the minimal API version does not support being cross compiled for different CPU architectures. It is best built with the same CPU architecture where the build machine is targeting to.**
+
+Ensure you have Docker installed and configured on your machine before executing this command. This Docker image can then be used to deploy the application in containerized environments such as Kubernetes or Docker Compose setups.
+
+## Docker Deployment
+
+To deploy the Docker container of this GeoFeed application, simply pull the image for the following variants:
+
+- MVC Variant ``docker pull git.startmywifi.com/as1024/geofeed:latest``
+- Minimal API Variant ``docker pull git.startmywifi.com/as1024/geofeed:aot-minimal``
+
+To configure the container, please refer to the Configuration section above. You should be able to configure this with either an environment variable or map an ``appSettings.json`` file to the container.
+
 ## Endpoints
 
 The application provides the following key endpoints: