2 files changed, 126 insertions, 3 deletions
diff --git a/Jellyfin.Server.Implementations/Extensions/ExpressionExtensions.cs b/Jellyfin.Server.Implementations/Extensions/ExpressionExtensions.cs
new file mode 100644
index 000000000..d70ac672f
--- /dev/null
+++ b/Jellyfin.Server.Implementations/Extensions/ExpressionExtensions.cs
@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+
+namespace Jellyfin.Server.Implementations.Extensions;
+
+/// <summary>
+/// Provides <see cref="Expression"/> extension methods.
+/// </summary>
+public static class ExpressionExtensions
+{
+    /// <summary>
+    /// Combines two predicates into a single predicate using a logical OR operation.
+    /// </summary>
+    /// <typeparam name="T">The predicate parameter type.</typeparam>
+    /// <param name="firstPredicate">The first predicate expression to combine.</param>
+    /// <param name="secondPredicate">The second predicate expression to combine.</param>
+    /// <returns>A new expression representing the OR combination of the input predicates.</returns>
+    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> firstPredicate, Expression<Func<T, bool>> secondPredicate)
+    {
+        ArgumentNullException.ThrowIfNull(firstPredicate);
+        ArgumentNullException.ThrowIfNull(secondPredicate);
+
+        var invokedExpression = Expression.Invoke(secondPredicate, firstPredicate.Parameters);
+        return Expression.Lambda<Func<T, bool>>(Expression.OrElse(firstPredicate.Body, invokedExpression), firstPredicate.Parameters);
+    }
+
+    /// <summary>
+    /// Combines multiple predicates into a single predicate using a logical OR operation.
+    /// </summary>
+    /// <typeparam name="T">The predicate parameter type.</typeparam>
+    /// <param name="predicates">A collection of predicate expressions to combine.</param>
+    /// <returns>A new expression representing the OR combination of all input predicates.</returns>
+    public static Expression<Func<T, bool>> Or<T>(this IEnumerable<Expression<Func<T, bool>>> predicates)
+    {
+        ArgumentNullException.ThrowIfNull(predicates);
+
+        return predicates.Aggregate((aggregatePredicate, nextPredicate) => aggregatePredicate.Or(nextPredicate));
+    }
+
+    /// <summary>
+    /// Combines two predicates into a single predicate using a logical AND operation.
+    /// </summary>
+    /// <typeparam name="T">The predicate parameter type.</typeparam>
+    /// <param name="firstPredicate">The first predicate expression to combine.</param>
+    /// <param name="secondPredicate">The second predicate expression to combine.</param>
+    /// <returns>A new expression representing the AND combination of the input predicates.</returns>
+    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> firstPredicate, Expression<Func<T, bool>> secondPredicate)
+    {
+        ArgumentNullException.ThrowIfNull(firstPredicate);
+        ArgumentNullException.ThrowIfNull(secondPredicate);
+
+        var invokedExpression = Expression.Invoke(secondPredicate, firstPredicate.Parameters);
+        return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(firstPredicate.Body, invokedExpression), firstPredicate.Parameters);
+    }
+
+    /// <summary>
+    /// Combines multiple predicates into a single predicate using a logical AND operation.
+    /// </summary>
+    /// <typeparam name="T">The predicate parameter type.</typeparam>
+    /// <param name="predicates">A collection of predicate expressions to combine.</param>
+    /// <returns>A new expression representing the AND combination of all input predicates.</returns>
+    public static Expression<Func<T, bool>> And<T>(this IEnumerable<Expression<Func<T, bool>>> predicates)
+    {
+        ArgumentNullException.ThrowIfNull(predicates);
+
+        return predicates.Aggregate((aggregatePredicate, nextPredicate) => aggregatePredicate.And(nextPredicate));
+    }
+}
diff --git a/Jellyfin.Server.Implementations/Extensions/ServiceCollectionExtensions.cs b/Jellyfin.Server.Implementations/Extensions/ServiceCollectionExtensions.cs
index fbbb5bca7..63c80634f 100644
--- a/Jellyfin.Server.Implementations/Extensions/ServiceCollectionExtensions.cs
+++ b/Jellyfin.Server.Implementations/Extensions/ServiceCollectionExtensions.cs
@@ -1,8 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using System.Reflection;
 using Jellyfin.Database.Implementations;
 using Jellyfin.Database.Implementations.DbConfiguration;
+using Jellyfin.Database.Implementations.Locking;
 using Jellyfin.Database.Providers.Sqlite;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Controller.Configuration;
@@ -41,6 +44,28 @@ public static class ServiceCollectionExtensions
         return items;
     }
 
+    private static JellyfinDbProviderFactory? LoadDatabasePlugin(CustomDatabaseOptions customProviderOptions, IApplicationPaths applicationPaths)
+    {
+        var plugin = Directory.EnumerateDirectories(applicationPaths.PluginsPath)
+            .Where(e => Path.GetFileName(e)!.StartsWith(customProviderOptions.PluginName, StringComparison.OrdinalIgnoreCase))
+            .Order()
+            .FirstOrDefault()
+            ?? throw new InvalidOperationException($"The requested custom database plugin with the name '{customProviderOptions.PluginName}' could not been found in '{applicationPaths.PluginsPath}'");
+
+        var dbProviderAssembly = Path.Combine(plugin, Path.ChangeExtension(customProviderOptions.PluginAssembly, "dll"));
+        if (!File.Exists(dbProviderAssembly))
+        {
+            throw new InvalidOperationException($"Could not find the requested assembly at '{dbProviderAssembly}'");
+        }
+
+        // we have to load the assembly without proxy to ensure maximum performance for this.
+        var assembly = Assembly.LoadFrom(dbProviderAssembly);
+        var dbProviderType = assembly.GetExportedTypes().FirstOrDefault(f => f.IsAssignableTo(typeof(IJellyfinDatabaseProvider)))
+            ?? throw new InvalidOperationException($"Could not find any type implementing the '{nameof(IJellyfinDatabaseProvider)}' interface.");
+
+        return (services) => (IJellyfinDatabaseProvider)ActivatorUtilities.CreateInstance(services, dbProviderType);
+    }
+
     /// <summary>
     /// Adds the <see cref="IDbContextFactory{TContext}"/> interface to the service collection with second level caching enabled.
     /// </summary>
@@ -54,7 +79,6 @@ public static class ServiceCollectionExtensions
         IConfiguration configuration)
     {
         var efCoreConfiguration = configurationManager.GetConfiguration<DatabaseConfigurationOptions>("database");
-        var providers = GetSupportedDbProviders();
         JellyfinDbProviderFactory? providerFactory = null;
 
         if (efCoreConfiguration?.DatabaseType is null)
@@ -73,22 +97,51 @@ public static class ServiceCollectionExtensions
                 efCoreConfiguration = new DatabaseConfigurationOptions()
                 {
                     DatabaseType = "Jellyfin-SQLite",
+                    LockingBehavior = DatabaseLockingBehaviorTypes.NoLock
                 };
                 configurationManager.SaveConfiguration("database", efCoreConfiguration);
             }
         }
 
-        if (!providers.TryGetValue(efCoreConfiguration.DatabaseType.ToUpperInvariant(), out providerFactory!))
+        if (efCoreConfiguration.DatabaseType.Equals("PLUGIN_PROVIDER", StringComparison.OrdinalIgnoreCase))
+        {
+            if (efCoreConfiguration.CustomProviderOptions is null)
+            {
+                throw new InvalidOperationException("The custom database provider must declare the custom provider options to work");
+            }
+
+            providerFactory = LoadDatabasePlugin(efCoreConfiguration.CustomProviderOptions, configurationManager.ApplicationPaths);
+        }
+        else
         {
-            throw new InvalidOperationException($"Jellyfin cannot find the database provider of type '{efCoreConfiguration.DatabaseType}'. Supported types are {string.Join(", ", providers.Keys)}");
+            var providers = GetSupportedDbProviders();
+            if (!providers.TryGetValue(efCoreConfiguration.DatabaseType.ToUpperInvariant(), out providerFactory!))
+            {
+                throw new InvalidOperationException($"Jellyfin cannot find the database provider of type '{efCoreConfiguration.DatabaseType}'. Supported types are {string.Join(", ", providers.Keys)}");
+            }
         }
 
         serviceCollection.AddSingleton<IJellyfinDatabaseProvider>(providerFactory!);
 
+        switch (efCoreConfiguration.LockingBehavior)
+        {
+            case DatabaseLockingBehaviorTypes.NoLock:
+                serviceCollection.AddSingleton<IEntityFrameworkCoreLockingBehavior, NoLockBehavior>();
+                break;
+            case DatabaseLockingBehaviorTypes.Pessimistic:
+                serviceCollection.AddSingleton<IEntityFrameworkCoreLockingBehavior, PessimisticLockBehavior>();
+                break;
+            case DatabaseLockingBehaviorTypes.Optimistic:
+                serviceCollection.AddSingleton<IEntityFrameworkCoreLockingBehavior, OptimisticLockBehavior>();
+                break;
+        }
+
         serviceCollection.AddPooledDbContextFactory<JellyfinDbContext>((serviceProvider, opt) =>
         {
             var provider = serviceProvider.GetRequiredService<IJellyfinDatabaseProvider>();
             provider.Initialise(opt);
+            var lockingBehavior = serviceProvider.GetRequiredService<IEntityFrameworkCoreLockingBehavior>();
+            lockingBehavior.Initialise(opt);
         });
 
         return serviceCollection;