Init cache on webapp startup

Author: siimav

RP1AnalyticsWebApp/Services/CacheService.cs

@@ -18,11 +18,13 @@ public class CacheService
 
         private readonly HybridCache _cache;
         private readonly TelemetryClient _telemetry;
+        private readonly ICareerLogDatabaseSettings _dbSettings;
 
-        public CacheService(HybridCache cache, TelemetryClient telemetry)
+        public CacheService(HybridCache cache, TelemetryClient telemetry, ICareerLogDatabaseSettings dbSettings)
         {
             _cache = cache;
             _telemetry = telemetry;
+            _dbSettings = dbSettings;
         }
 
         public async Task<List<CareerLog>> FetchAllCareersAsync(IMongoCollection<CareerLog> careerLogs)
@@ -40,6 +42,17 @@ public async Task InvalidateAsync()
             await _cache.RemoveAsync(CacheKey);
         }
 
+        public async Task InitCacheAsync(CancellationToken ct = default)
+        {
+            _telemetry.TrackEvent("InitCacheAsync");
+            IMongoCollection<CareerLog> careerLogs = CareerLogService.CreateCareerLogsMongoClient(_dbSettings);
+
+            await _cache.GetOrCreateAsync(
+                CacheKey,
+                FetchFromDB(careerLogs),
+                cancellationToken: ct);
+        }
+
         private Func<CancellationToken, ValueTask<CachedCareerLogs>> FetchFromDB(IMongoCollection<CareerLog> careerLogs)
         {
             return async cancel =>

RP1AnalyticsWebApp/Services/CareerLogService.cs

@@ -34,9 +34,14 @@ public CareerLogService(ICareerLogDatabaseSettings dbSettings, IContractSettings
             _userManager = userManager;
             _cache = cache;
 
+            _careerLogs = CreateCareerLogsMongoClient(dbSettings);
+        }
+
+        public static IMongoCollection<CareerLog> CreateCareerLogsMongoClient(ICareerLogDatabaseSettings dbSettings)
+        {
             var client = new MongoClient(dbSettings.ConnectionString);
             var database = client.GetDatabase(dbSettings.DatabaseName);
-            _careerLogs = database.GetCollection<CareerLog>(dbSettings.CareerLogsCollectionName);
+            return database.GetCollection<CareerLog>(dbSettings.CareerLogsCollectionName);
         }
 
         public async Task<List<CareerLog>> GetAsync(ODataQueryOptions<CareerLog> queryOptions = null)

RP1AnalyticsWebApp/Services/StartupHostedService.cs

@@ -11,6 +11,7 @@ namespace RP1AnalyticsWebApp.Services
     public class StartupHostedService : IHostedService
     {
         private readonly IServiceProvider _serviceProvider;
+
         public StartupHostedService(IServiceProvider serviceProvider)
         {
             _serviceProvider = serviceProvider;
@@ -19,24 +20,33 @@ public StartupHostedService(IServiceProvider serviceProvider)
         public async Task StartAsync(CancellationToken cancellationToken)
         {
             using IServiceScope scope = _serviceProvider.CreateScope();
-            await EnsureRoles(scope);
+            var rolesTask = EnsureRolesAsync(scope);
+            _ = PreloadCacheAsync(scope, cancellationToken);    // Start but do not wait for completion
+
+            await rolesTask;
         }
 
         public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
 
-        private static async Task EnsureRoles(IServiceScope scope)
+        private static async Task EnsureRolesAsync(IServiceScope scope)
         {
             var _roleManager = scope.ServiceProvider.GetRequiredService<RoleManager<MongoRole>>();
-            await Task.WhenAll(EnsureRole(_roleManager, Constants.Roles.Admin),
-                               EnsureRole(_roleManager, Constants.Roles.Member));
+            await Task.WhenAll(EnsureRoleAsync(_roleManager, Constants.Roles.Admin),
+                               EnsureRoleAsync(_roleManager, Constants.Roles.Member));
         }
 
-        private static async Task EnsureRole(RoleManager<MongoRole> _roleManager, string roleName)
+        private static async Task EnsureRoleAsync(RoleManager<MongoRole> _roleManager, string roleName)
         {
             if (!await _roleManager.RoleExistsAsync(roleName))
             {
                 await _roleManager.CreateAsync(new MongoRole(roleName));
             }
         }
+
+        private static async Task PreloadCacheAsync(IServiceScope scope, CancellationToken cancellationToken)
+        {
+            var cache = scope.ServiceProvider.GetRequiredService<CacheService>();
+            await cache.InitCacheAsync(cancellationToken);
+        }
     }
 }