| | | 1 | | #pragma warning disable MT1013 // Releasing lock without guarantee of execution |
| | | 2 | | #pragma warning disable MT1012 // Acquiring lock without guarantee of releasing |
| | | 3 | | #pragma warning disable CA1873 |
| | | 4 | | |
| | | 5 | | using System; |
| | | 6 | | using System.Data; |
| | | 7 | | using System.Data.Common; |
| | | 8 | | using System.Runtime.CompilerServices; |
| | | 9 | | using System.Threading; |
| | | 10 | | using System.Threading.Tasks; |
| | | 11 | | using Microsoft.EntityFrameworkCore; |
| | | 12 | | using Microsoft.EntityFrameworkCore.Diagnostics; |
| | | 13 | | using Microsoft.Extensions.Logging; |
| | | 14 | | |
| | | 15 | | namespace Jellyfin.Database.Implementations.Locking; |
| | | 16 | | |
| | | 17 | | /// <summary> |
| | | 18 | | /// A locking behavior that will always block any operation while a write is requested. Mimicks the old SqliteRepository |
| | | 19 | | /// </summary> |
| | | 20 | | /// <remarks> |
| | | 21 | | /// Unsafe with asynchronous transactions; because <see cref="ReaderWriterLockSlim"/> is |
| | | 22 | | /// thread-affine, holding it from <c>TransactionStarting</c> to <c>TransactionCommitted</c> |
| | | 23 | | /// works only while continuations resume inline. A genuinely-async continuation inside a |
| | | 24 | | /// transaction releases on another thread, throwing |
| | | 25 | | /// <see cref="SynchronizationLockException"/> or deadlocking a later write. |
| | | 26 | | /// </remarks> |
| | | 27 | | public class PessimisticLockBehavior : IEntityFrameworkCoreLockingBehavior |
| | | 28 | | { |
| | | 29 | | private readonly ILogger<PessimisticLockBehavior> _logger; |
| | | 30 | | private readonly ILoggerFactory _loggerFactory; |
| | | 31 | | |
| | | 32 | | /// <summary> |
| | | 33 | | /// Initializes a new instance of the <see cref="PessimisticLockBehavior"/> class. |
| | | 34 | | /// </summary> |
| | | 35 | | /// <param name="logger">The application logger.</param> |
| | | 36 | | /// <param name="loggerFactory">The logger factory.</param> |
| | | 37 | | public PessimisticLockBehavior(ILogger<PessimisticLockBehavior> logger, ILoggerFactory loggerFactory) |
| | | 38 | | { |
| | 0 | 39 | | _logger = logger; |
| | 0 | 40 | | _loggerFactory = loggerFactory; |
| | 0 | 41 | | } |
| | | 42 | | |
| | 0 | 43 | | private static ReaderWriterLockSlim DatabaseLock { get; } = new(LockRecursionPolicy.SupportsRecursion); |
| | | 44 | | |
| | | 45 | | /// <inheritdoc/> |
| | | 46 | | public void OnSaveChanges(JellyfinDbContext context, Action saveChanges) |
| | | 47 | | { |
| | 0 | 48 | | using (DbLock.EnterWrite(_logger)) |
| | | 49 | | { |
| | 0 | 50 | | saveChanges(); |
| | 0 | 51 | | } |
| | 0 | 52 | | } |
| | | 53 | | |
| | | 54 | | /// <inheritdoc/> |
| | | 55 | | public void Initialise(DbContextOptionsBuilder optionsBuilder) |
| | | 56 | | { |
| | 0 | 57 | | _logger.LogWarning( |
| | 0 | 58 | | "The database locking mode has been set to: Pessimistic. This mode is not safe with asynchronous tran |
| | 0 | 59 | | optionsBuilder.AddInterceptors(new CommandLockingInterceptor(_loggerFactory.CreateLogger<CommandLockingIntercept |
| | 0 | 60 | | optionsBuilder.AddInterceptors(new TransactionLockingInterceptor(_loggerFactory.CreateLogger<TransactionLockingI |
| | 0 | 61 | | } |
| | | 62 | | |
| | | 63 | | /// <inheritdoc/> |
| | | 64 | | public async Task OnSaveChangesAsync(JellyfinDbContext context, Func<Task> saveChanges) |
| | | 65 | | { |
| | 0 | 66 | | using (DbLock.EnterWrite(_logger)) |
| | | 67 | | { |
| | 0 | 68 | | await saveChanges().ConfigureAwait(false); |
| | 0 | 69 | | } |
| | 0 | 70 | | } |
| | | 71 | | |
| | | 72 | | private sealed class TransactionLockingInterceptor : DbTransactionInterceptor |
| | | 73 | | { |
| | | 74 | | private readonly ILogger _logger; |
| | | 75 | | |
| | 0 | 76 | | public TransactionLockingInterceptor(ILogger logger) |
| | | 77 | | { |
| | 0 | 78 | | _logger = logger; |
| | 0 | 79 | | } |
| | | 80 | | |
| | | 81 | | public override InterceptionResult<DbTransaction> TransactionStarting(DbConnection connection, TransactionStarti |
| | | 82 | | { |
| | 0 | 83 | | DbLock.BeginWriteLock(_logger); |
| | | 84 | | |
| | 0 | 85 | | return base.TransactionStarting(connection, eventData, result); |
| | | 86 | | } |
| | | 87 | | |
| | | 88 | | public override ValueTask<InterceptionResult<DbTransaction>> TransactionStartingAsync(DbConnection connection, T |
| | | 89 | | { |
| | 0 | 90 | | DbLock.BeginWriteLock(_logger); |
| | | 91 | | |
| | 0 | 92 | | return base.TransactionStartingAsync(connection, eventData, result, cancellationToken); |
| | | 93 | | } |
| | | 94 | | |
| | | 95 | | public override void TransactionCommitted(DbTransaction transaction, TransactionEndEventData eventData) |
| | | 96 | | { |
| | 0 | 97 | | DbLock.EndWriteLock(_logger); |
| | | 98 | | |
| | 0 | 99 | | base.TransactionCommitted(transaction, eventData); |
| | 0 | 100 | | } |
| | | 101 | | |
| | | 102 | | public override Task TransactionCommittedAsync(DbTransaction transaction, TransactionEndEventData eventData, Can |
| | | 103 | | { |
| | 0 | 104 | | DbLock.EndWriteLock(_logger); |
| | | 105 | | |
| | 0 | 106 | | return base.TransactionCommittedAsync(transaction, eventData, cancellationToken); |
| | | 107 | | } |
| | | 108 | | |
| | | 109 | | public override void TransactionFailed(DbTransaction transaction, TransactionErrorEventData eventData) |
| | | 110 | | { |
| | 0 | 111 | | DbLock.EndWriteLock(_logger); |
| | | 112 | | |
| | 0 | 113 | | base.TransactionFailed(transaction, eventData); |
| | 0 | 114 | | } |
| | | 115 | | |
| | | 116 | | public override Task TransactionFailedAsync(DbTransaction transaction, TransactionErrorEventData eventData, Canc |
| | | 117 | | { |
| | 0 | 118 | | DbLock.EndWriteLock(_logger); |
| | | 119 | | |
| | 0 | 120 | | return base.TransactionFailedAsync(transaction, eventData, cancellationToken); |
| | | 121 | | } |
| | | 122 | | |
| | | 123 | | public override void TransactionRolledBack(DbTransaction transaction, TransactionEndEventData eventData) |
| | | 124 | | { |
| | 0 | 125 | | DbLock.EndWriteLock(_logger); |
| | | 126 | | |
| | 0 | 127 | | base.TransactionRolledBack(transaction, eventData); |
| | 0 | 128 | | } |
| | | 129 | | |
| | | 130 | | public override Task TransactionRolledBackAsync(DbTransaction transaction, TransactionEndEventData eventData, Ca |
| | | 131 | | { |
| | 0 | 132 | | DbLock.EndWriteLock(_logger); |
| | | 133 | | |
| | 0 | 134 | | return base.TransactionRolledBackAsync(transaction, eventData, cancellationToken); |
| | | 135 | | } |
| | | 136 | | } |
| | | 137 | | |
| | | 138 | | /// <summary> |
| | | 139 | | /// Adds strict read/write locking. |
| | | 140 | | /// </summary> |
| | | 141 | | private sealed class CommandLockingInterceptor : DbCommandInterceptor |
| | | 142 | | { |
| | | 143 | | private readonly ILogger _logger; |
| | | 144 | | |
| | 0 | 145 | | public CommandLockingInterceptor(ILogger logger) |
| | | 146 | | { |
| | 0 | 147 | | _logger = logger; |
| | 0 | 148 | | } |
| | | 149 | | |
| | | 150 | | public override InterceptionResult<int> NonQueryExecuting(DbCommand command, CommandEventData eventData, Interce |
| | | 151 | | { |
| | 0 | 152 | | using (DbLock.EnterWrite(_logger, command)) |
| | | 153 | | { |
| | 0 | 154 | | return InterceptionResult<int>.SuppressWithResult(command.ExecuteNonQuery()); |
| | | 155 | | } |
| | 0 | 156 | | } |
| | | 157 | | |
| | | 158 | | public override async ValueTask<InterceptionResult<int>> NonQueryExecutingAsync(DbCommand command, CommandEventD |
| | | 159 | | { |
| | 0 | 160 | | using (DbLock.EnterWrite(_logger, command)) |
| | | 161 | | { |
| | 0 | 162 | | return InterceptionResult<int>.SuppressWithResult(await command.ExecuteNonQueryAsync(cancellationToken). |
| | | 163 | | } |
| | 0 | 164 | | } |
| | | 165 | | |
| | | 166 | | public override InterceptionResult<object> ScalarExecuting(DbCommand command, CommandEventData eventData, Interc |
| | | 167 | | { |
| | 0 | 168 | | using (DbLock.EnterRead(_logger)) |
| | | 169 | | { |
| | 0 | 170 | | return InterceptionResult<object>.SuppressWithResult(command.ExecuteScalar()!); |
| | | 171 | | } |
| | 0 | 172 | | } |
| | | 173 | | |
| | | 174 | | public override async ValueTask<InterceptionResult<object>> ScalarExecutingAsync(DbCommand command, CommandEvent |
| | | 175 | | { |
| | 0 | 176 | | using (DbLock.EnterRead(_logger)) |
| | | 177 | | { |
| | 0 | 178 | | return InterceptionResult<object>.SuppressWithResult((await command.ExecuteScalarAsync(cancellationToken |
| | | 179 | | } |
| | 0 | 180 | | } |
| | | 181 | | |
| | | 182 | | public override InterceptionResult<DbDataReader> ReaderExecuting(DbCommand command, CommandEventData eventData, |
| | | 183 | | { |
| | 0 | 184 | | using (DbLock.EnterRead(_logger)) |
| | | 185 | | { |
| | 0 | 186 | | return InterceptionResult<DbDataReader>.SuppressWithResult(command.ExecuteReader()!); |
| | | 187 | | } |
| | 0 | 188 | | } |
| | | 189 | | |
| | | 190 | | public override async ValueTask<InterceptionResult<DbDataReader>> ReaderExecutingAsync(DbCommand command, Comman |
| | | 191 | | { |
| | 0 | 192 | | using (DbLock.EnterRead(_logger)) |
| | | 193 | | { |
| | 0 | 194 | | return InterceptionResult<DbDataReader>.SuppressWithResult(await command.ExecuteReaderAsync(cancellation |
| | | 195 | | } |
| | 0 | 196 | | } |
| | | 197 | | } |
| | | 198 | | |
| | | 199 | | private sealed class DbLock : IDisposable |
| | | 200 | | { |
| | | 201 | | private readonly Action? _action; |
| | | 202 | | private bool _disposed; |
| | | 203 | | |
| | 0 | 204 | | private static readonly IDisposable _noLock = new DbLock(null) { _disposed = true }; |
| | | 205 | | private static (string Command, Guid Id, DateTimeOffset QueryDate, bool Printed) _blockQuery; |
| | | 206 | | |
| | | 207 | | public DbLock(Action? action = null) |
| | | 208 | | { |
| | 0 | 209 | | _action = action; |
| | 0 | 210 | | } |
| | | 211 | | |
| | | 212 | | #pragma warning disable IDISP015 // Member should not return created and cached instance |
| | | 213 | | public static IDisposable EnterWrite(ILogger logger, IDbCommand? command = null, [CallerMemberName] string? call |
| | | 214 | | #pragma warning restore IDISP015 // Member should not return created and cached instance |
| | | 215 | | { |
| | 0 | 216 | | logger.LogTrace("Enter Write for {Caller}:{Line}", callerMemberName, callerNo); |
| | 0 | 217 | | if (DatabaseLock.IsWriteLockHeld) |
| | | 218 | | { |
| | 0 | 219 | | logger.LogTrace("Write Held {Caller}:{Line}", callerMemberName, callerNo); |
| | 0 | 220 | | return _noLock; |
| | | 221 | | } |
| | | 222 | | |
| | 0 | 223 | | BeginWriteLock(logger, command, callerMemberName, callerNo); |
| | 0 | 224 | | return new DbLock(() => |
| | 0 | 225 | | { |
| | 0 | 226 | | EndWriteLock(logger, callerMemberName, callerNo); |
| | 0 | 227 | | }); |
| | | 228 | | } |
| | | 229 | | |
| | | 230 | | #pragma warning disable IDISP015 // Member should not return created and cached instance |
| | | 231 | | public static IDisposable EnterRead(ILogger logger, [CallerMemberName] string? callerMemberName = null, [CallerL |
| | | 232 | | #pragma warning restore IDISP015 // Member should not return created and cached instance |
| | | 233 | | { |
| | 0 | 234 | | logger.LogTrace("Enter Read {Caller}:{Line}", callerMemberName, callerNo); |
| | 0 | 235 | | if (DatabaseLock.IsWriteLockHeld) |
| | | 236 | | { |
| | 0 | 237 | | logger.LogTrace("Write Held {Caller}:{Line}", callerMemberName, callerNo); |
| | 0 | 238 | | return _noLock; |
| | | 239 | | } |
| | | 240 | | |
| | 0 | 241 | | BeginReadLock(logger, callerMemberName, callerNo); |
| | 0 | 242 | | return new DbLock(() => |
| | 0 | 243 | | { |
| | 0 | 244 | | ExitReadLock(logger, callerMemberName, callerNo); |
| | 0 | 245 | | }); |
| | | 246 | | } |
| | | 247 | | |
| | | 248 | | public static void BeginWriteLock(ILogger logger, IDbCommand? command = null, [CallerMemberName] string? callerM |
| | | 249 | | { |
| | 0 | 250 | | logger.LogTrace("Aquire Write {Caller}:{Line}", callerMemberName, callerNo); |
| | 0 | 251 | | if (!DatabaseLock.TryEnterWriteLock(TimeSpan.FromMilliseconds(1000))) |
| | | 252 | | { |
| | 0 | 253 | | var blockingQuery = _blockQuery; |
| | 0 | 254 | | if (!blockingQuery.Printed) |
| | | 255 | | { |
| | 0 | 256 | | _blockQuery = (blockingQuery.Command, blockingQuery.Id, blockingQuery.QueryDate, true); |
| | 0 | 257 | | logger.LogInformation("QueryLock: {Id} --- {Query}", blockingQuery.Id, blockingQuery.Command); |
| | | 258 | | } |
| | | 259 | | |
| | 0 | 260 | | logger.LogInformation("Query congestion detected: '{Id}' since '{Date}'", blockingQuery.Id, blockingQuer |
| | | 261 | | |
| | 0 | 262 | | DatabaseLock.EnterWriteLock(); |
| | | 263 | | |
| | 0 | 264 | | logger.LogInformation("Query congestion cleared: '{Id}' for '{Date}'", blockingQuery.Id, DateTimeOffset. |
| | | 265 | | } |
| | | 266 | | |
| | 0 | 267 | | _blockQuery = (command?.CommandText ?? "Transaction", Guid.NewGuid(), DateTimeOffset.Now, false); |
| | | 268 | | |
| | 0 | 269 | | logger.LogTrace("Write Aquired {Caller}:{Line}", callerMemberName, callerNo); |
| | 0 | 270 | | } |
| | | 271 | | |
| | | 272 | | public static void BeginReadLock(ILogger logger, [CallerMemberName] string? callerMemberName = null, [CallerLine |
| | | 273 | | { |
| | 0 | 274 | | logger.LogTrace("Aquire Write {Caller}:{Line}", callerMemberName, callerNo); |
| | 0 | 275 | | DatabaseLock.EnterReadLock(); |
| | 0 | 276 | | logger.LogTrace("Read Aquired {Caller}:{Line}", callerMemberName, callerNo); |
| | 0 | 277 | | } |
| | | 278 | | |
| | | 279 | | public static void EndWriteLock(ILogger logger, [CallerMemberName] string? callerMemberName = null, [CallerLineN |
| | | 280 | | { |
| | 0 | 281 | | logger.LogTrace("Release Write {Caller}:{Line}", callerMemberName, callerNo); |
| | 0 | 282 | | DatabaseLock.ExitWriteLock(); |
| | 0 | 283 | | } |
| | | 284 | | |
| | | 285 | | public static void ExitReadLock(ILogger logger, [CallerMemberName] string? callerMemberName = null, [CallerLineN |
| | | 286 | | { |
| | 0 | 287 | | logger.LogTrace("Release Read {Caller}:{Line}", callerMemberName, callerNo); |
| | 0 | 288 | | DatabaseLock.ExitReadLock(); |
| | 0 | 289 | | } |
| | | 290 | | |
| | | 291 | | public void Dispose() |
| | | 292 | | { |
| | 0 | 293 | | if (_disposed) |
| | | 294 | | { |
| | 0 | 295 | | return; |
| | | 296 | | } |
| | | 297 | | |
| | 0 | 298 | | _disposed = true; |
| | 0 | 299 | | if (_action is not null) |
| | | 300 | | { |
| | 0 | 301 | | _action(); |
| | | 302 | | } |
| | 0 | 303 | | } |
| | | 304 | | } |
| | | 305 | | } |