Rename the GetGeofeed Method to Async

AS1024.GeoFeed.Core.SqliteGeoFeedCache/GeoFeedSqliteCache.cs

@@ -58,7 +58,7 @@ namespace AS1024.GeoFeed.Core.GeoFeedSqliteLocalCache
             List<IPGeoFeed> cachedData = [];
             results.ForEach(cachedData.Add);
 
-            return cachedData.ToGeoFeedCsv();
+            return cachedData.ToGeoFeedCsv(true, true);
         }
 
         private async Task DBContextMigrate()

AS1024.GeoFeed.Core.WebLogic/AS1024.GeoFeed.Core.WebLogic.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+	<OutputType>Library</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\AS1024.GeoFeed.Core\AS1024.GeoFeed.Core.csproj" />
+  </ItemGroup>
+
+</Project>

AS1024.GeoFeed.Core.WebLogic/GeoFeedRetrurn.cs

@@ -0,0 +1,70 @@
+using System.Text;
+using AS1024.GeoFeed.Core.Interfaces;
+using AS1024.GeoFeed.Core.Tools;
+using AS1024.GeoFeed.Models;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace AS1024.GeoFeed.Core.WebLogic
+{
+    public class GeoFeedReturn
+    {
+        private const string GeoFeedCacheKey = "GeoFeedData";
+        private readonly IGeoFeedProvider provider;
+        private readonly ILogger<GeoFeedReturn> logger;
+        private readonly IGeoFeedPersistentCacheProvider cacheProvider;
+        private readonly IMemoryCache memoryCache;
+        private readonly IWebHostEnvironment environment;
+
+        public GeoFeedReturn(IGeoFeedProvider provider,
+                ILogger<GeoFeedReturn> logger,
+                IGeoFeedPersistentCacheProvider cacheProvider,
+                IMemoryCache memoryCache,
+                IWebHostEnvironment environment)
+        {
+            this.provider = provider;
+            this.logger = logger;
+            this.cacheProvider = cacheProvider;
+            this.memoryCache = memoryCache;
+            this.environment = environment;
+        }
+
+        public async Task<IResult> GetGeoFeed()
+        {
+            bool isCached = true;
+            try
+            {
+                if (!memoryCache.TryGetValue(GeoFeedCacheKey, out List<IPGeoFeed>? feed))
+                {
+                    isCached = false;
+                    feed = await provider.GetGeoFeedDataAsync();
+                    if (environment.IsProduction())
+                    {
+                        MemoryCacheEntryOptions cacheEntryOptions = new MemoryCacheEntryOptions()
+                            .SetSlidingExpiration(TimeSpan.FromMinutes(15));
+                        memoryCache.Set(GeoFeedCacheKey, feed, cacheEntryOptions);
+                    }
+                }
+
+                return Results.File(Encoding.UTF8.GetBytes(feed.ToGeoFeedCsv(true, isCached)),
+                                        "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();
+        }
+    }
+}

AS1024.GeoFeed.Core.WebLogic/Properties/launchSettings.json

@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "AS1024.GeoFeed.Core.WebLogic": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "https://localhost:54455;http://localhost:54456"
+    }
+  }
+}

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

@@ -4,6 +4,7 @@
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <OutputType>Library</OutputType>
   </PropertyGroup>
 
   <ItemGroup>

AS1024.GeoFeed.Core/CacheService/GeoFeedCacheService.cs

@@ -42,7 +42,7 @@ namespace AS1024.GeoFeed.Core.CacheService
                     var persistentCacheProvider = 
                         scope.ServiceProvider.GetRequiredService<IGeoFeedPersistentCacheProvider>();
 
-                    var results = await feedProvider.GetGeoFeedData();
+                    var results = await feedProvider.GetGeoFeedDataAsync();
                     await persistentCacheProvider.CacheGeoFeed(results);
                 }
                 catch (Exception)

AS1024.GeoFeed.Core/GeoFeedPreloader/PreloadGeoFeed.cs

@@ -41,7 +41,7 @@ namespace AS1024.GeoFeed.Core.GeoFeedPreloader
         private async Task StartPreLoad()
         {
             logger.LogInformation("Preloading GeoFeed data in memory...");
-            List<IPGeoFeed> feed = await provider.GetGeoFeedData();
+            List<IPGeoFeed> feed = await provider.GetGeoFeedDataAsync();
             MemoryCacheEntryOptions cacheEntryOptions = new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(45));
             memoryCache.Set(GeoFeedCacheKey, feed, cacheEntryOptions);
         }

AS1024.GeoFeed.Core/GeoFeedProviders/NetBoxGeoFeedProviderBase.cs

@@ -31,7 +31,7 @@ namespace AS1024.GeoFeed.Core.GeoFeedProviders
             this.httpClientFactory = httpClientFactory;
         }
 
-        public async Task<List<IPGeoFeed>> GetGeoFeedData()
+        public async Task<List<IPGeoFeed>> GetGeoFeedDataAsync()
         {
             List<IPGeoFeed> geoFeed = [];
             using HttpClient client = httpClientFactory.CreateClient();

AS1024.GeoFeed.Core/Interfaces/IGeoFeedProvider.cs

@@ -5,6 +5,6 @@ namespace AS1024.GeoFeed.Core.Interfaces
     public interface IGeoFeedProvider
     {
         public string GeoFeedProviderName { get; }
-        public Task<List<IPGeoFeed>> GetGeoFeedData();
+        public Task<List<IPGeoFeed>> GetGeoFeedDataAsync();
     }
 }

AS1024.GeoFeed.Core/Tools/GeoFeedTools.cs

@@ -5,10 +5,23 @@ namespace AS1024.GeoFeed.Core.Tools
 {
     public static class GeoFeedTools
     {
-        public static string ToGeoFeedCsv(this List<IPGeoFeed> geoFeeds)
+        /// <summary>
+        /// Returns a CSV string for a given GeoFeed retreived from various sources
+        /// </summary>
+        /// <param name="geoFeeds">GeoFeed returned from the source of truth</param>
+        /// <param name="timeStamp">If a timestamp should be appended at the header</param>
+        /// <param name="isCached">If the result is cached</param>
+        /// <returns></returns>
+        public static string ToGeoFeedCsv(this List<IPGeoFeed> geoFeeds, bool timeStamp = false, bool isCached = false)
         {
             StringBuilder csvContent = new();
 
+            if (timeStamp)
+                csvContent.AppendLine($"# GeoFeed generated on {DateTime.UtcNow:R}");
+
+            if (isCached)
+                csvContent.AppendLine($"# Geofeed data is returned from local in memory cache");
+
             foreach (IPGeoFeed feed in geoFeeds)
             {
                 csvContent.AppendLine($"{feed.Prefix},{feed.GeolocCountry},{feed.GeolocRegion},{feed.GeolocCity},{feed.GeolocPostalCode}");

AS1024.GeoFeed.MinimalAPI/AS1024.GeoFeed.MinimalAPI.csproj

@@ -14,6 +14,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\AS1024.GeoFeed.Core.WebLogic\AS1024.GeoFeed.Core.WebLogic.csproj" />
     <ProjectReference Include="..\AS1024.GeoFeed.Core\AS1024.GeoFeed.Core.csproj" />
   </ItemGroup>
 

AS1024.GeoFeed.MinimalAPI/Program.cs

@@ -1,15 +1,7 @@
 using AS1024.GeoFeed.Core.CacheService;
-using AS1024.GeoFeed.Core.GeoFeedProviders;
+using AS1024.GeoFeed.Core.GeoFeedPreloader;
 using AS1024.GeoFeed.Core.Interfaces;
-using AS1024.GeoFeed.Core.Tools;
+using AS1024.GeoFeed.Core.WebLogic;
-using AS1024.GeoFeed.Models;
-using Microsoft.AspNetCore.Http.HttpResults;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using System;
-using System.Text;
 
 namespace AS1024.GeoFeed.MinimalAPI
 {
@@ -21,7 +13,9 @@ namespace AS1024.GeoFeed.MinimalAPI
             var builder = WebApplication.CreateSlimBuilder(args);
             builder.Services.AddTransient<IGeoFeedProvider, NetboxAoTGeoFeedProvider>();
             builder.Services.AddHostedService<GeoFeedCacheService>();
+            builder.Services.AddHostedService<PreLoadGeoFeed>();
             builder.Services.AddTransient<IGeoFeedPersistentCacheProvider, GeoFeedLocalFileCache>();
+            builder.Services.AddScoped<GeoFeedReturn>();
             builder.Services.AddMemoryCache();
             builder.Services.AddLogging();
             builder.Services.AddHttpClient();
@@ -30,64 +24,15 @@ namespace AS1024.GeoFeed.MinimalAPI
             });
             var app = builder.Build();
 
-            app.Map("/geofeed.csv", async (IGeoFeedProvider provider, 
+            app.Map("/geofeed.csv", async (GeoFeedReturn feedReturn) => {
-                ILogger<Program> logger, 
+                return await feedReturn.GetGeoFeed();
-                IGeoFeedPersistentCacheProvider cacheProvider,
-                IMemoryCache memoryCache,
-                IWebHostEnvironment environment) => {
-                    return await GeoFeedDataRunner(provider, logger, cacheProvider, memoryCache, environment);
             });
 
-            app.Map("/geofeed", async (IGeoFeedProvider provider,
+            app.Map("/geofeed", async (GeoFeedReturn feedReturn) => {
-                ILogger<Program> logger,
+                return await feedReturn.GetGeoFeed();
-                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();
-        }
     }
 }

AS1024.GeoFeed.sln

@@ -14,7 +14,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AS1024.GeoFeed.Core", "AS10
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AS1024.GeoFeed.MinimalAPI", "AS1024.GeoFeed.MinimalAPI\AS1024.GeoFeed.MinimalAPI.csproj", "{36F2958C-8D0E-463B-9BF3-D6E55E6FC0B8}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AS1024.GeoFeed.Core.SqliteGeoFeedCache", "AS1024.GeoFeed.Core.SqliteGeoFeedCache\AS1024.GeoFeed.Core.SqliteGeoFeedCache.csproj", "{3459BB31-FA7A-44D1-872D-C5338ACFBF80}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AS1024.GeoFeed.Core.SqliteGeoFeedCache", "AS1024.GeoFeed.Core.SqliteGeoFeedCache\AS1024.GeoFeed.Core.SqliteGeoFeedCache.csproj", "{3459BB31-FA7A-44D1-872D-C5338ACFBF80}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AS1024.GeoFeed.Core.WebLogic", "AS1024.GeoFeed.Core.WebLogic\AS1024.GeoFeed.Core.WebLogic.csproj", "{58BDCE89-FCC0-478F-BBDE-B89833712AAB}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -42,6 +44,10 @@ Global
 		{3459BB31-FA7A-44D1-872D-C5338ACFBF80}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{3459BB31-FA7A-44D1-872D-C5338ACFBF80}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{3459BB31-FA7A-44D1-872D-C5338ACFBF80}.Release|Any CPU.Build.0 = Release|Any CPU
+		{58BDCE89-FCC0-478F-BBDE-B89833712AAB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{58BDCE89-FCC0-478F-BBDE-B89833712AAB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{58BDCE89-FCC0-478F-BBDE-B89833712AAB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{58BDCE89-FCC0-478F-BBDE-B89833712AAB}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

AS1024.GeoFeed/AS1024.GeoFeed.csproj

@@ -23,6 +23,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\AS1024.GeoFeed.Core.SqliteGeoFeedCache\AS1024.GeoFeed.Core.SqliteGeoFeedCache.csproj" />
+    <ProjectReference Include="..\AS1024.GeoFeed.Core.WebLogic\AS1024.GeoFeed.Core.WebLogic.csproj" />
     <ProjectReference Include="..\AS1024.GeoFeed.Core\AS1024.GeoFeed.Core.csproj" />
     <ProjectReference Include="..\AS1024.GeoFeed.Models\AS1024.GeoFeed.Models.csproj" />
   </ItemGroup>

AS1024.GeoFeed/Controllers/GeofeedController.cs

@@ -1,9 +1,5 @@
 using Microsoft.AspNetCore.Mvc;
-using AS1024.GeoFeed.Core.Interfaces;
+using AS1024.GeoFeed.Core.WebLogic;
-using Microsoft.Extensions.Caching.Memory;
-using AS1024.GeoFeed.Models;
-using System.Text;
-using AS1024.GeoFeed.Core.Tools;
 
 namespace AS1024.GeoFeed.Controllers
 {
@@ -13,75 +9,18 @@ namespace AS1024.GeoFeed.Controllers
 
     public class GeofeedController : ControllerBase
     {
-        private readonly IGeoFeedProvider builder;
+        private readonly GeoFeedReturn feedReturn;
-        private readonly IMemoryCache memoryCache;
-        private readonly IWebHostEnvironment environment;
-        private readonly ILogger<GeofeedController> logger;
-        private readonly IGeoFeedPersistentCacheProvider geoFeedPersistentCache;
-        private const string GeoFeedCacheKey = "GeoFeedData";
 
-        public GeofeedController(IGeoFeedProvider builder,
+        public GeofeedController(GeoFeedReturn feedReturn)
-            IMemoryCache memoryCache,
+        {
-            IWebHostEnvironment environment,
+            this.feedReturn = feedReturn;
-            ILogger<GeofeedController> logger,
-            IGeoFeedPersistentCacheProvider geoFeedPersistentCache) {
-            this.logger = logger;
-            this.geoFeedPersistentCache = geoFeedPersistentCache;
-            this.builder = builder;
-            this.memoryCache = memoryCache;
-            this.environment = environment;
         }
 
         [HttpGet]
         [Route("")]
-        public async Task<IActionResult> Get()
+        public async Task<IResult> Get()
         {
-            try
+            return await feedReturn.GetGeoFeed();
-            {
-                if (!memoryCache.TryGetValue(GeoFeedCacheKey, out List<IPGeoFeed>? feed))
-                {
-                    feed = await builder.GetGeoFeedData();
-                    if (environment.IsProduction())
-                    {
-                        MemoryCacheEntryOptions cacheEntryOptions = new MemoryCacheEntryOptions()
-                            .SetSlidingExpiration(TimeSpan.FromMinutes(15));
-                        memoryCache.Set(GeoFeedCacheKey, feed, cacheEntryOptions);
-                    }
-                }
-
-                return ReturnFile(feed);
-            } catch (HttpRequestException ex)
-            {
-                logger.LogWarning($"Temporary failure of retrieving GeoData from upstream. {ex}");
-                var cachedData = geoFeedPersistentCache.GetGeoFeed();
-                return ReturnFile(cachedData);
-            }
-
-            catch (Exception ex)
-            {
-                logger.LogError($"Geofeed generation failed. Exception: {ex}");
-                return StatusCode(500);
-            }
-
-        }
-
-        [NonAction]
-        private IActionResult ReturnFile(List<IPGeoFeed>? feed)
-        {
-            string csvContent = feed.ToGeoFeedCsv(); // Assuming ToGeoFeedCsv() returns a string in CSV format.
-            return ReturnFile(csvContent);
-        }
-
-        [NonAction]
-        private IActionResult ReturnFile(string csvContent)
-        {
-            byte[] contentBytes = Encoding.UTF8.GetBytes(csvContent);
-            string contentType = "text/csv";
-
-            return new FileContentResult(contentBytes, contentType)
-            {
-                FileDownloadName = "geofeed.csv"
-            };
         }
     }
 }

AS1024.GeoFeed/Program.cs

@@ -4,6 +4,7 @@ using AS1024.GeoFeed.Core.GeoFeedProviders;
 using Microsoft.EntityFrameworkCore;
 using AS1024.GeoFeed.Core.GeoFeedSqliteLocalCache;
 using AS1024.GeoFeed.Core.CacheService;
+using AS1024.GeoFeed.Core.WebLogic;
 
 namespace AS1024.GeoFeed
 {
@@ -15,6 +16,7 @@ namespace AS1024.GeoFeed
 
             builder.Services.AddHostedService<PreLoadGeoFeed>();
             builder.Services.AddTransient<IGeoFeedProvider, NetBoxGeoFeedProvider>();
+            builder.Services.AddScoped<GeoFeedReturn>();
             builder.Services.AddDbContext<GeoFeedCacheDbContext>(
                 options =>
                 {