GeoFeed/AS1024.GeoFeed.MinimalAPI/Program.cs

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 Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;

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();
            builder.Services.ConfigureHttpJsonOptions(options => {
                options.SerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonSerializerContext.Default);
            });
            var app = builder.Build();

            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<string> 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 feed.ToGeoFeedCsv();
            }
            catch (HttpRequestException ex)
            {
                logger.LogWarning($"Temporary failure of retrieving GeoData from upstream. {ex}");
                string geoFeedData = cacheProvider.GetGeoFeed();
                return geoFeedData;
            }
            catch (Exception ex)
            {
                logger.LogError($"Error: {ex}");
            }

            return "";
        }
    }
}