1 files changed, 94 insertions, 85 deletions
diff --git a/Jellyfin.Server.Implementations/Devices/DeviceManager.cs b/Jellyfin.Server.Implementations/Devices/DeviceManager.cs
index 0728f1179..a4b4c1959 100644
--- a/Jellyfin.Server.Implementations/Devices/DeviceManager.cs
+++ b/Jellyfin.Server.Implementations/Devices/DeviceManager.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using Jellyfin.Data.Entities;
@@ -8,6 +9,7 @@ using Jellyfin.Data.Enums;
 using Jellyfin.Data.Events;
 using Jellyfin.Data.Queries;
 using Jellyfin.Extensions;
+using MediaBrowser.Common.Extensions;
 using MediaBrowser.Controller.Devices;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Devices;
@@ -22,7 +24,7 @@ namespace Jellyfin.Server.Implementations.Devices
     /// </summary>
     public class DeviceManager : IDeviceManager
     {
-        private readonly JellyfinDbProvider _dbProvider;
+        private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
         private readonly IUserManager _userManager;
         private readonly ConcurrentDictionary<string, ClientCapabilities> _capabilitiesMap = new();
 
@@ -31,7 +33,7 @@ namespace Jellyfin.Server.Implementations.Devices
         /// </summary>
         /// <param name="dbProvider">The database provider.</param>
         /// <param name="userManager">The user manager.</param>
-        public DeviceManager(JellyfinDbProvider dbProvider, IUserManager userManager)
+        public DeviceManager(IDbContextFactory<JellyfinDbContext> dbProvider, IUserManager userManager)
         {
             _dbProvider = dbProvider;
             _userManager = userManager;
@@ -49,39 +51,50 @@ namespace Jellyfin.Server.Implementations.Devices
         /// <inheritdoc />
         public async Task UpdateDeviceOptions(string deviceId, string deviceName)
         {
-            await using var dbContext = _dbProvider.CreateContext();
-            var deviceOptions = await dbContext.DeviceOptions.AsQueryable().FirstOrDefaultAsync(dev => dev.DeviceId == deviceId).ConfigureAwait(false);
-            if (deviceOptions == null)
+            DeviceOptions? deviceOptions;
+            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
+            await using (dbContext.ConfigureAwait(false))
             {
-                deviceOptions = new DeviceOptions(deviceId);
-                dbContext.DeviceOptions.Add(deviceOptions);
+                deviceOptions = await dbContext.DeviceOptions.FirstOrDefaultAsync(dev => dev.DeviceId == deviceId).ConfigureAwait(false);
+                if (deviceOptions is null)
+                {
+                    deviceOptions = new DeviceOptions(deviceId);
+                    dbContext.DeviceOptions.Add(deviceOptions);
+                }
+
+                deviceOptions.CustomName = deviceName;
+                await dbContext.SaveChangesAsync().ConfigureAwait(false);
             }
 
-            deviceOptions.CustomName = deviceName;
-            await dbContext.SaveChangesAsync().ConfigureAwait(false);
-
             DeviceOptionsUpdated?.Invoke(this, new GenericEventArgs<Tuple<string, DeviceOptions>>(new Tuple<string, DeviceOptions>(deviceId, deviceOptions)));
         }
 
         /// <inheritdoc />
         public async Task<Device> CreateDevice(Device device)
         {
-            await using var dbContext = _dbProvider.CreateContext();
+            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
+            await using (dbContext.ConfigureAwait(false))
+            {
+                dbContext.Devices.Add(device);
 
-            dbContext.Devices.Add(device);
+                await dbContext.SaveChangesAsync().ConfigureAwait(false);
+            }
 
-            await dbContext.SaveChangesAsync().ConfigureAwait(false);
             return device;
         }
 
         /// <inheritdoc />
         public async Task<DeviceOptions> GetDeviceOptions(string deviceId)
         {
-            await using var dbContext = _dbProvider.CreateContext();
-            var deviceOptions = await dbContext.DeviceOptions
-                .AsQueryable()
-                .FirstOrDefaultAsync(d => d.DeviceId == deviceId)
-                .ConfigureAwait(false);
+            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
+            DeviceOptions? deviceOptions;
+            await using (dbContext.ConfigureAwait(false))
+            {
+                deviceOptions = await dbContext.DeviceOptions
+                    .AsNoTracking()
+                    .FirstOrDefaultAsync(d => d.DeviceId == deviceId)
+                    .ConfigureAwait(false);
+            }
 
             return deviceOptions ?? new DeviceOptions(deviceId);
         }
@@ -97,16 +110,19 @@ namespace Jellyfin.Server.Implementations.Devices
         /// <inheritdoc />
         public async Task<DeviceInfo?> GetDevice(string id)
         {
-            await using var dbContext = _dbProvider.CreateContext();
-            var device = await dbContext.Devices
-                .AsQueryable()
-                .Where(d => d.DeviceId == id)
-                .OrderByDescending(d => d.DateLastActivity)
-                .Include(d => d.User)
-                .FirstOrDefaultAsync()
-                .ConfigureAwait(false);
+            Device? device;
+            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
+            await using (dbContext.ConfigureAwait(false))
+            {
+                device = await dbContext.Devices
+                    .Where(d => d.DeviceId == id)
+                    .OrderByDescending(d => d.DateLastActivity)
+                    .Include(d => d.User)
+                    .FirstOrDefaultAsync()
+                    .ConfigureAwait(false);
+            }
 
-            var deviceInfo = device == null ? null : ToDeviceInfo(device);
+            var deviceInfo = device is null ? null : ToDeviceInfo(device);
 
             return deviceInfo;
         }
@@ -114,41 +130,29 @@ namespace Jellyfin.Server.Implementations.Devices
         /// <inheritdoc />
         public async Task<QueryResult<Device>> GetDevices(DeviceQuery query)
         {
-            await using var dbContext = _dbProvider.CreateContext();
-
-            var devices = dbContext.Devices.AsQueryable();
-
-            if (query.UserId.HasValue)
+            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
+            await using (dbContext.ConfigureAwait(false))
             {
-                devices = devices.Where(device => device.UserId.Equals(query.UserId.Value));
-            }
+                var devices = dbContext.Devices
+                    .OrderBy(d => d.Id)
+                    .Where(device => !query.UserId.HasValue || device.UserId.Equals(query.UserId.Value))
+                    .Where(device => query.DeviceId == null || device.DeviceId == query.DeviceId)
+                    .Where(device => query.AccessToken == null || device.AccessToken == query.AccessToken);
 
-            if (query.DeviceId != null)
-            {
-                devices = devices.Where(device => device.DeviceId == query.DeviceId);
-            }
-
-            if (query.AccessToken != null)
-            {
-                devices = devices.Where(device => device.AccessToken == query.AccessToken);
-            }
+                var count = await devices.CountAsync().ConfigureAwait(false);
 
-            var count = await devices.CountAsync().ConfigureAwait(false);
+                if (query.Skip.HasValue)
+                {
+                    devices = devices.Skip(query.Skip.Value);
+                }
 
-            if (query.Skip.HasValue)
-            {
-                devices = devices.Skip(query.Skip.Value);
-            }
+                if (query.Limit.HasValue)
+                {
+                    devices = devices.Take(query.Limit.Value);
+                }
 
-            if (query.Limit.HasValue)
-            {
-                devices = devices.Take(query.Limit.Value);
+                return new QueryResult<Device>(query.Skip, count, await devices.ToListAsync().ConfigureAwait(false));
             }
-
-            return new QueryResult<Device>(
-                query.Skip,
-                count,
-                await devices.ToListAsync().ConfigureAwait(false));
         }
 
         /// <inheritdoc />
@@ -165,48 +169,53 @@ namespace Jellyfin.Server.Implementations.Devices
         /// <inheritdoc />
         public async Task<QueryResult<DeviceInfo>> GetDevicesForUser(Guid? userId, bool? supportsSync)
         {
-            await using var dbContext = _dbProvider.CreateContext();
-            var sessions = dbContext.Devices
-                .Include(d => d.User)
-                .AsQueryable()
-                .OrderByDescending(d => d.DateLastActivity)
-                .ThenBy(d => d.DeviceId)
-                .AsAsyncEnumerable();
-
-            if (supportsSync.HasValue)
+            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
+            await using (dbContext.ConfigureAwait(false))
             {
-                sessions = sessions.Where(i => GetCapabilities(i.DeviceId).SupportsSync == supportsSync.Value);
-            }
-
-            if (userId.HasValue)
-            {
-                var user = _userManager.GetUserById(userId.Value);
-
-                sessions = sessions.Where(i => CanAccessDevice(user, i.DeviceId));
+                IAsyncEnumerable<Device> sessions = dbContext.Devices
+                    .Include(d => d.User)
+                    .OrderByDescending(d => d.DateLastActivity)
+                    .ThenBy(d => d.DeviceId)
+                    .AsAsyncEnumerable();
+
+                if (supportsSync.HasValue)
+                {
+                    sessions = sessions.Where(i => GetCapabilities(i.DeviceId).SupportsSync == supportsSync.Value);
+                }
+
+                if (userId.HasValue)
+                {
+                    var user = _userManager.GetUserById(userId.Value);
+                    if (user is null)
+                    {
+                        throw new ResourceNotFoundException();
+                    }
+
+                    sessions = sessions.Where(i => CanAccessDevice(user, i.DeviceId));
+                }
+
+                var array = await sessions.Select(device => ToDeviceInfo(device)).ToArrayAsync().ConfigureAwait(false);
+
+                return new QueryResult<DeviceInfo>(array);
             }
-
-            var array = await sessions.Select(device => ToDeviceInfo(device)).ToArrayAsync().ConfigureAwait(false);
-
-            return new QueryResult<DeviceInfo>(array);
         }
 
         /// <inheritdoc />
         public async Task DeleteDevice(Device device)
         {
-            await using var dbContext = _dbProvider.CreateContext();
-            dbContext.Devices.Remove(device);
-            await dbContext.SaveChangesAsync().ConfigureAwait(false);
+            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
+            await using (dbContext.ConfigureAwait(false))
+            {
+                dbContext.Devices.Remove(device);
+                await dbContext.SaveChangesAsync().ConfigureAwait(false);
+            }
         }
 
         /// <inheritdoc />
         public bool CanAccessDevice(User user, string deviceId)
         {
             ArgumentNullException.ThrowIfNull(user);
-
-            if (string.IsNullOrEmpty(deviceId))
-            {
-                throw new ArgumentNullException(nameof(deviceId));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(deviceId);
 
             if (user.HasPermission(PermissionKind.EnableAllDevices) || user.HasPermission(PermissionKind.IsAdministrator))
             {