Add necessary tools

AS1024.GeoFeed/AS1024.GeoFeed.csproj

@@ -14,6 +14,10 @@
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="8.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="8.0.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.19.5" />
   </ItemGroup>
 

AS1024.GeoFeed/GeoFeedBuilder/GeoFeedCacheService.cs

@@ -1,63 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using AS1024.GeoFeed.Models;
-using AS1024.GeoFeed.GeoFeedBuilder;
-using Microsoft.EntityFrameworkCore;
-using AS1024.GeoFeed.Interfaces;
-
-namespace AS1024.GeoFeed.GeoFeedCacheService
-{
-    public class GeoFeedCacheService : IHostedService
-    {
-        CancellationToken _cancellationToken;
-        private readonly ILogger<GeoFeedCacheService> logger;
-        private readonly IGeoFeedProvider feedProvider;
-
-        public GeoFeedCacheService(ILogger<GeoFeedCacheService> logger,
-        IGeoFeedProvider feedProvider)
-        {
-            this.logger = logger;
-            this.feedProvider = feedProvider;
-        }
-
-        public Task StartAsync(CancellationToken cancellationToken)
-        {
-            _ = StartPerioidicSync();
-            return Task.CompletedTask;
-        }
-
-        public Task StopAsync(CancellationToken cancellationToken)
-        {
-            return Task.CompletedTask;
-        }
-
-        public async Task<bool> StartPerioidicSync(){
-            List<GeoFeedCacheEntry> geoFeedCacheEntry = [];
-            while (!_cancellationToken.IsCancellationRequested) {
-                await Task.Delay(TimeSpan.FromMinutes(30));
-                logger.LogInformation("Running on disk fallback cache process...");
-                var results = await feedProvider.GetGeoFeedData();
-
-                results.ForEach(x => {
-                    geoFeedCacheEntry.Add(new (){
-                        Prefix = x.Prefix,
-                        GeolocCity = x.GeolocCity,
-                        GeolocCountry = x.GeolocCountry,
-                        GeolocHasLocation = x.GeolocHasLocation,
-                        GeolocPostalCode = x.GeolocPostalCode,
-                        GeolocRegion = x.GeolocRegion
-                    });
-                });
-            }
-            return false;
-        }
-    }
-
-    public class GeoFeedCacheEntry : IPGeoFeed {
-        [Key]
-        public int Id { get; set; }
-    }
-
-    public class GeoFeedCacheDbContext : DbContext {
-        public virtual DbSet<GeoFeedCacheEntry> GeoFeedCacheEntries {get;set;}
-    }
-}

AS1024.GeoFeed/GeoFeedLocalCache/GeoFeedCacheDbContext.cs

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

AS1024.GeoFeed/GeoFeedLocalCache/GeoFeedCacheEntry.cs

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

AS1024.GeoFeed/GeoFeedLocalCache/GeoFeedCacheService.cs

@@ -0,0 +1,89 @@
+using AS1024.GeoFeed.Interfaces;
+using Microsoft.EntityFrameworkCore;
+using System.Runtime.CompilerServices;
+
+namespace AS1024.GeoFeed.GeoFeedLocalCache
+{
+    public class GeoFeedCacheService : IHostedService
+    {
+        CancellationToken _cancellationToken;
+        private readonly ILogger<GeoFeedCacheService> logger;
+        private readonly IGeoFeedProvider feedProvider;
+        private readonly IHost host;
+
+        public GeoFeedCacheService(ILogger<GeoFeedCacheService> logger,
+        IGeoFeedProvider feedProvider,
+        IHost host)
+        {
+            this.logger = logger;
+            this.feedProvider = feedProvider;
+            this.host = host;
+        }
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            _ = StartPerioidicSync();
+            return Task.CompletedTask;
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
+        }
+
+        public async Task<bool> StartPerioidicSync()
+        {
+            await DBContextMigrate();
+
+            List<GeoFeedCacheEntry> geoFeedCacheEntry = [];
+            while (!_cancellationToken.IsCancellationRequested)
+            {
+                await Task.Delay(TimeSpan.FromMinutes(30));
+                logger.LogInformation("Running on disk fallback cache process...");
+                try
+                {
+                    using var scope = host.Services.CreateScope();
+                    using var dbContext = scope.ServiceProvider.GetRequiredService<GeoFeedCacheDbContext>();
+                    var results = await feedProvider.GetGeoFeedData();
+
+                    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();
+                }
+                catch (Exception ex)
+                {
+                    logger.LogWarning("On disk cache failed to run. Waiting on 30 minutes before retry...");
+                }
+            }
+
+            return false;
+        }
+
+        private async Task DBContextMigrate()
+        {
+            using IServiceScope scope = host.Services.CreateScope();
+            using GeoFeedCacheDbContext? dbContext =
+                host.Services.GetService<GeoFeedCacheDbContext>();
+            if (dbContext.Database.GetPendingMigrations().Any())
+            {
+                await dbContext.Database.MigrateAsync();
+            }
+        }
+    }
+}

AS1024.GeoFeed/GeoFeedLocalCache/GeoFeedDesignTimeMigration.cs

@@ -0,0 +1,16 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Design;
+
+namespace AS1024.GeoFeed.GeoFeedLocalCache
+{
+    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/Migrations/20240108180753_DiskCacheMigration.Designer.cs

@@ -0,0 +1,54 @@
+// <auto-generated />
+using System;
+using AS1024.GeoFeed.GeoFeedLocalCache;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace AS1024.GeoFeed.Migrations
+{
+    [DbContext(typeof(GeoFeedCacheDbContext))]
+    [Migration("20240108180753_DiskCacheMigration")]
+    partial class DiskCacheMigration
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "8.0.0");
+
+            modelBuilder.Entity("AS1024.GeoFeed.GeoFeedLocalCache.GeoFeedCacheEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("GeolocCity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("GeolocCountry")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool?>("GeolocHasLocation")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("GeolocPostalCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("GeolocRegion")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Prefix")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GeoFeedCacheEntries");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

AS1024.GeoFeed/Migrations/20240108180753_DiskCacheMigration.cs

@@ -0,0 +1,39 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace AS1024.GeoFeed.Migrations
+{
+    /// <inheritdoc />
+    public partial class DiskCacheMigration : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "GeoFeedCacheEntries",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    GeolocCity = table.Column<string>(type: "TEXT", nullable: true),
+                    GeolocCountry = table.Column<string>(type: "TEXT", nullable: true),
+                    GeolocHasLocation = table.Column<bool>(type: "INTEGER", nullable: true),
+                    GeolocRegion = table.Column<string>(type: "TEXT", nullable: true),
+                    GeolocPostalCode = table.Column<string>(type: "TEXT", nullable: true),
+                    Prefix = table.Column<string>(type: "TEXT", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_GeoFeedCacheEntries", x => x.Id);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "GeoFeedCacheEntries");
+        }
+    }
+}

AS1024.GeoFeed/Migrations/GeoFeedCacheDbContextModelSnapshot.cs

@@ -0,0 +1,51 @@
+// <auto-generated />
+using System;
+using AS1024.GeoFeed.GeoFeedLocalCache;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace AS1024.GeoFeed.Migrations
+{
+    [DbContext(typeof(GeoFeedCacheDbContext))]
+    partial class GeoFeedCacheDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "8.0.0");
+
+            modelBuilder.Entity("AS1024.GeoFeed.GeoFeedLocalCache.GeoFeedCacheEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("GeolocCity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("GeolocCountry")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool?>("GeolocHasLocation")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("GeolocPostalCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("GeolocRegion")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Prefix")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GeoFeedCacheEntries");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

AS1024.GeoFeed/Program.cs

@@ -1,5 +1,7 @@
 using AS1024.GeoFeed.GeoFeedBuilder;
+using AS1024.GeoFeed.GeoFeedLocalCache;
 using AS1024.GeoFeed.Interfaces;
+using Microsoft.EntityFrameworkCore;
 
 namespace AS1024.GeoFeed
 {
@@ -11,6 +13,11 @@ namespace AS1024.GeoFeed
 
             builder.Services.AddHostedService<PreLoadGeoFeed>();
             builder.Services.AddTransient<IGeoFeedProvider, NetBoxGeoFeedProvider>();
+            builder.Services.AddHostedService<GeoFeedCacheService>();
+            builder.Services.AddDbContext<GeoFeedCacheDbContext>(options =>
+            {
+                options.UseSqlite(builder.Configuration.GetConnectionString("LocalFeedCache"));
+            });
             builder.Services.AddHttpClient();
             builder.Services.AddMemoryCache();
             // Add services to the container.