remove JellyfinDbProvider and add second level caching

2 files changed, 111 insertions, 101 deletions

diff --git a/Jellyfin.Server.Implementations/Security/AuthenticationManager.cs b/Jellyfin.Server.Implementations/Security/AuthenticationManager.cs
index b79e46469..33c08c8c2 100644
--- a/Jellyfin.Server.Implementations/Security/AuthenticationManager.cs
+++ b/Jellyfin.Server.Implementations/Security/AuthenticationManager.cs
@@ -10,13 +10,13 @@ namespace Jellyfin.Server.Implementations.Security
     /// <inheritdoc />
     public class AuthenticationManager : IAuthenticationManager
     {
-        private readonly JellyfinDbProvider _dbProvider;
+        private readonly IDbContextFactory<JellyfinDb> _dbProvider;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="AuthenticationManager"/> class.
         /// </summary>
         /// <param name="dbProvider">The database provider.</param>
-        public AuthenticationManager(JellyfinDbProvider dbProvider)
+        public AuthenticationManager(IDbContextFactory<JellyfinDb> dbProvider)
         {
             _dbProvider = dbProvider;
         }
@@ -24,50 +24,56 @@ namespace Jellyfin.Server.Implementations.Security
         /// <inheritdoc />
         public async Task CreateApiKey(string name)
         {
-            await using var dbContext = _dbProvider.CreateContext();
-
-            dbContext.ApiKeys.Add(new ApiKey(name));
+            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
+            await using (dbContext.ConfigureAwait(false))
+            {
+                dbContext.ApiKeys.Add(new ApiKey(name));
 
-            await dbContext.SaveChangesAsync().ConfigureAwait(false);
+                await dbContext.SaveChangesAsync().ConfigureAwait(false);
+            }
         }
 
         /// <inheritdoc />
         public async Task<IReadOnlyList<AuthenticationInfo>> GetApiKeys()
         {
-            await using var dbContext = _dbProvider.CreateContext();
-
-            return await dbContext.ApiKeys
-                .AsAsyncEnumerable()
-                .Select(key => new AuthenticationInfo
-                {
-                    AppName = key.Name,
-                    AccessToken = key.AccessToken,
-                    DateCreated = key.DateCreated,
-                    DeviceId = string.Empty,
-                    DeviceName = string.Empty,
-                    AppVersion = string.Empty
-                }).ToListAsync().ConfigureAwait(false);
+            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
+            await using (dbContext.ConfigureAwait(false))
+            {
+                return await dbContext.ApiKeys
+                    .AsAsyncEnumerable()
+                    .Select(key => new AuthenticationInfo
+                    {
+                        AppName = key.Name,
+                        AccessToken = key.AccessToken,
+                        DateCreated = key.DateCreated,
+                        DeviceId = string.Empty,
+                        DeviceName = string.Empty,
+                        AppVersion = string.Empty
+                    }).ToListAsync().ConfigureAwait(false);
+            }
         }
 
         /// <inheritdoc />
         public async Task DeleteApiKey(string accessToken)
         {
-            await using var dbContext = _dbProvider.CreateContext();
-
-            var key = await dbContext.ApiKeys
-                .AsQueryable()
-                .Where(apiKey => apiKey.AccessToken == accessToken)
-                .FirstOrDefaultAsync()
-                .ConfigureAwait(false);
-
-            if (key == null)
+            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
+            await using (dbContext.ConfigureAwait(false))
             {
-                return;
-            }
+                var key = await dbContext.ApiKeys
+                    .AsQueryable()
+                    .Where(apiKey => apiKey.AccessToken == accessToken)
+                    .FirstOrDefaultAsync()
+                    .ConfigureAwait(false);
 
-            dbContext.Remove(key);
+                if (key == null)
+                {
+                    return;
+                }
+
+                dbContext.Remove(key);
 
-            await dbContext.SaveChangesAsync().ConfigureAwait(false);
+                await dbContext.SaveChangesAsync().ConfigureAwait(false);
+            }
         }
     }
 }
diff --git a/Jellyfin.Server.Implementations/Security/AuthorizationContext.cs b/Jellyfin.Server.Implementations/Security/AuthorizationContext.cs
index 9f813f532..4d1a1b3cf 100644
--- a/Jellyfin.Server.Implementations/Security/AuthorizationContext.cs
+++ b/Jellyfin.Server.Implementations/Security/AuthorizationContext.cs
@@ -4,6 +4,7 @@ using System;
 using System.Collections.Generic;
 using System.Net;
 using System.Threading.Tasks;
+using EFCoreSecondLevelCacheInterceptor;
 using MediaBrowser.Controller;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Net;
@@ -15,12 +16,12 @@ namespace Jellyfin.Server.Implementations.Security
 {
     public class AuthorizationContext : IAuthorizationContext
     {
-        private readonly JellyfinDbProvider _jellyfinDbProvider;
+        private readonly IDbContextFactory<JellyfinDb> _jellyfinDbProvider;
         private readonly IUserManager _userManager;
         private readonly IServerApplicationHost _serverApplicationHost;
 
         public AuthorizationContext(
-            JellyfinDbProvider jellyfinDb,
+            IDbContextFactory<JellyfinDb> jellyfinDb,
             IUserManager userManager,
             IServerApplicationHost serverApplicationHost)
         {
@@ -121,96 +122,99 @@ namespace Jellyfin.Server.Implementations.Security
 #pragma warning restore CA1508
 
             authInfo.HasToken = true;
-            await using var dbContext = _jellyfinDbProvider.CreateContext();
-            var device = await dbContext.Devices.FirstOrDefaultAsync(d => d.AccessToken == token).ConfigureAwait(false);
-
-            if (device != null)
+            var dbContext = await _jellyfinDbProvider.CreateDbContextAsync().ConfigureAwait(false);
+            await using (dbContext.ConfigureAwait(false))
             {
-                authInfo.IsAuthenticated = true;
-                var updateToken = false;
-
-                // TODO: Remove these checks for IsNullOrWhiteSpace
-                if (string.IsNullOrWhiteSpace(authInfo.Client))
-                {
-                    authInfo.Client = device.AppName;
-                }
+                var device = await dbContext.Devices.FirstOrDefaultAsync(d => d.AccessToken == token).ConfigureAwait(false);
 
-                if (string.IsNullOrWhiteSpace(authInfo.DeviceId))
+                if (device != null)
                 {
-                    authInfo.DeviceId = device.DeviceId;
-                }
-
-                // Temporary. TODO - allow clients to specify that the token has been shared with a casting device
-                var allowTokenInfoUpdate = !authInfo.Client.Contains("chromecast", StringComparison.OrdinalIgnoreCase);
+                    authInfo.IsAuthenticated = true;
+                    var updateToken = false;
 
-                if (string.IsNullOrWhiteSpace(authInfo.Device))
-                {
-                    authInfo.Device = device.DeviceName;
-                }
-                else if (!string.Equals(authInfo.Device, device.DeviceName, StringComparison.OrdinalIgnoreCase))
-                {
-                    if (allowTokenInfoUpdate)
+                    // TODO: Remove these checks for IsNullOrWhiteSpace
+                    if (string.IsNullOrWhiteSpace(authInfo.Client))
                     {
-                        updateToken = true;
-                        device.DeviceName = authInfo.Device;
+                        authInfo.Client = device.AppName;
                     }
-                }
 
-                if (string.IsNullOrWhiteSpace(authInfo.Version))
-                {
-                    authInfo.Version = device.AppVersion;
-                }
-                else if (!string.Equals(authInfo.Version, device.AppVersion, StringComparison.OrdinalIgnoreCase))
-                {
-                    if (allowTokenInfoUpdate)
+                    if (string.IsNullOrWhiteSpace(authInfo.DeviceId))
                     {
-                        updateToken = true;
-                        device.AppVersion = authInfo.Version;
+                        authInfo.DeviceId = device.DeviceId;
                     }
-                }
 
-                if ((DateTime.UtcNow - device.DateLastActivity).TotalMinutes > 3)
-                {
-                    device.DateLastActivity = DateTime.UtcNow;
-                    updateToken = true;
-                }
+                    // Temporary. TODO - allow clients to specify that the token has been shared with a casting device
+                    var allowTokenInfoUpdate = !authInfo.Client.Contains("chromecast", StringComparison.OrdinalIgnoreCase);
 
-                authInfo.User = _userManager.GetUserById(device.UserId);
+                    if (string.IsNullOrWhiteSpace(authInfo.Device))
+                    {
+                        authInfo.Device = device.DeviceName;
+                    }
+                    else if (!string.Equals(authInfo.Device, device.DeviceName, StringComparison.OrdinalIgnoreCase))
+                    {
+                        if (allowTokenInfoUpdate)
+                        {
+                            updateToken = true;
+                            device.DeviceName = authInfo.Device;
+                        }
+                    }
 
-                if (updateToken)
-                {
-                    dbContext.Devices.Update(device);
-                    await dbContext.SaveChangesAsync().ConfigureAwait(false);
-                }
-            }
-            else
-            {
-                var key = await dbContext.ApiKeys.FirstOrDefaultAsync(apiKey => apiKey.AccessToken == token).ConfigureAwait(false);
-                if (key != null)
-                {
-                    authInfo.IsAuthenticated = true;
-                    authInfo.Client = key.Name;
-                    authInfo.Token = key.AccessToken;
-                    if (string.IsNullOrWhiteSpace(authInfo.DeviceId))
+                    if (string.IsNullOrWhiteSpace(authInfo.Version))
                     {
-                        authInfo.DeviceId = _serverApplicationHost.SystemId;
+                        authInfo.Version = device.AppVersion;
+                    }
+                    else if (!string.Equals(authInfo.Version, device.AppVersion, StringComparison.OrdinalIgnoreCase))
+                    {
+                        if (allowTokenInfoUpdate)
+                        {
+                            updateToken = true;
+                            device.AppVersion = authInfo.Version;
+                        }
                     }
 
-                    if (string.IsNullOrWhiteSpace(authInfo.Device))
+                    if ((DateTime.UtcNow - device.DateLastActivity).TotalMinutes > 3)
                     {
-                        authInfo.Device = _serverApplicationHost.Name;
+                        device.DateLastActivity = DateTime.UtcNow;
+                        updateToken = true;
                     }
 
-                    if (string.IsNullOrWhiteSpace(authInfo.Version))
+                    authInfo.User = _userManager.GetUserById(device.UserId);
+
+                    if (updateToken)
                     {
-                        authInfo.Version = _serverApplicationHost.ApplicationVersionString;
+                        dbContext.Devices.Update(device);
+                        await dbContext.SaveChangesAsync().ConfigureAwait(false);
                     }
+                }
+                else
+                {
+                    var key = await dbContext.ApiKeys.FirstOrDefaultAsync(apiKey => apiKey.AccessToken == token).ConfigureAwait(false);
+                    if (key != null)
+                    {
+                        authInfo.IsAuthenticated = true;
+                        authInfo.Client = key.Name;
+                        authInfo.Token = key.AccessToken;
+                        if (string.IsNullOrWhiteSpace(authInfo.DeviceId))
+                        {
+                            authInfo.DeviceId = _serverApplicationHost.SystemId;
+                        }
+
+                        if (string.IsNullOrWhiteSpace(authInfo.Device))
+                        {
+                            authInfo.Device = _serverApplicationHost.Name;
+                        }
+
+                        if (string.IsNullOrWhiteSpace(authInfo.Version))
+                        {
+                            authInfo.Version = _serverApplicationHost.ApplicationVersionString;
+                        }
 
-                    authInfo.IsApiKey = true;
+                        authInfo.IsApiKey = true;
+                    }
                 }
-            }
 
-            return authInfo;
+                return authInfo;
+            }
         }
 
         /// <summary>