1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-22 22:23:01 +08:00
osu-lazer/osu.Game/Database/DatabaseContextFactory.cs

178 lines
6.7 KiB
C#
Raw Normal View History

// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
2018-04-13 17:19:50 +08:00
using System.Linq;
2018-04-13 17:19:50 +08:00
using System.Threading;
using Microsoft.EntityFrameworkCore.Storage;
2018-04-13 17:19:50 +08:00
using osu.Framework.Platform;
using osu.Framework.Statistics;
2018-04-13 17:19:50 +08:00
namespace osu.Game.Database
{
public class DatabaseContextFactory : IDatabaseContextFactory
{
private readonly Storage storage;
2018-04-13 17:19:50 +08:00
private const string database_name = @"client.db";
2018-04-13 17:19:50 +08:00
private ThreadLocal<OsuDbContext> threadContexts;
private readonly object writeLock = new object();
private bool currentWriteDidWrite;
private bool currentWriteDidError;
2018-04-13 17:19:50 +08:00
private int currentWriteUsages;
private IDbContextTransaction currentWriteTransaction;
public DatabaseContextFactory(Storage storage)
2018-04-13 17:19:50 +08:00
{
this.storage = storage;
2018-04-13 17:19:50 +08:00
recycleThreadContexts();
}
private static readonly GlobalStatistic<int> reads = GlobalStatistics.Get<int>("Database", "Get (Read)");
private static readonly GlobalStatistic<int> writes = GlobalStatistics.Get<int>("Database", "Get (Write)");
private static readonly GlobalStatistic<int> commits = GlobalStatistics.Get<int>("Database", "Commits");
private static readonly GlobalStatistic<int> rollbacks = GlobalStatistics.Get<int>("Database", "Rollbacks");
2018-04-13 17:19:50 +08:00
/// <summary>
/// Get a context for the current thread for read-only usage.
/// If a <see cref="DatabaseWriteUsage"/> is in progress, the existing write-safe context will be returned.
/// </summary>
public OsuDbContext Get()
{
reads.Value++;
return threadContexts.Value;
}
2018-04-13 17:19:50 +08:00
/// <summary>
/// Request a context for write usage. Can be consumed in a nested fashion (and will return the same underlying context).
/// This method may block if a write is already active on a different thread.
/// </summary>
/// <param name="withTransaction">Whether to start a transaction for this write.</param>
2018-04-13 17:19:50 +08:00
/// <returns>A usage containing a usable context.</returns>
public DatabaseWriteUsage GetForWrite(bool withTransaction = true)
2018-04-13 17:19:50 +08:00
{
writes.Value++;
2018-04-13 17:19:50 +08:00
Monitor.Enter(writeLock);
OsuDbContext context;
2018-04-13 17:19:50 +08:00
try
{
if (currentWriteTransaction == null && withTransaction)
{
// this mitigates the fact that changes on tracked entities will not be rolled back with the transaction by ensuring write operations are always executed in isolated contexts.
// if this results in sub-optimal efficiency, we may need to look into removing Database-level transactions in favour of running SaveChanges where we currently commit the transaction.
if (threadContexts.IsValueCreated)
recycleThreadContexts();
context = threadContexts.Value;
currentWriteTransaction = context.Database.BeginTransaction();
}
else
{
// we want to try-catch the retrieval of the context because it could throw an error (in CreateContext).
context = threadContexts.Value;
}
}
2019-04-25 16:36:17 +08:00
catch
{
// retrieval of a context could trigger a fatal error.
Monitor.Exit(writeLock);
throw;
}
2018-04-13 17:19:50 +08:00
Interlocked.Increment(ref currentWriteUsages);
return new DatabaseWriteUsage(context, usageCompleted) { IsTransactionLeader = currentWriteTransaction != null && currentWriteUsages == 1 };
2018-04-13 17:19:50 +08:00
}
private void usageCompleted(DatabaseWriteUsage usage)
{
int usages = Interlocked.Decrement(ref currentWriteUsages);
try
{
currentWriteDidWrite |= usage.PerformedWrite;
currentWriteDidError |= usage.Errors.Any();
2018-04-13 17:19:50 +08:00
if (usages == 0)
2018-04-13 17:19:50 +08:00
{
if (currentWriteDidError)
{
rollbacks.Value++;
currentWriteTransaction?.Rollback();
}
else
{
commits.Value++;
currentWriteTransaction?.Commit();
}
if (currentWriteDidWrite || currentWriteDidError)
{
// explicitly dispose to ensure any outstanding flushes happen as soon as possible (and underlying resources are purged).
usage.Context.Dispose();
// once all writes are complete, we want to refresh thread-specific contexts to make sure they don't have stale local caches.
recycleThreadContexts();
}
currentWriteTransaction = null;
currentWriteDidWrite = false;
currentWriteDidError = false;
2018-04-13 17:19:50 +08:00
}
}
finally
{
Monitor.Exit(writeLock);
}
}
private void recycleThreadContexts()
{
// Contexts for other threads are not disposed as they may be in use elsewhere. Instead, fresh contexts are exposed
// for other threads to use, and we rely on the finalizer inside OsuDbContext to handle their previous contexts
threadContexts?.Value.Dispose();
threadContexts = new ThreadLocal<OsuDbContext>(CreateContext, true);
}
2018-04-13 17:19:50 +08:00
protected virtual OsuDbContext CreateContext() => new OsuDbContext(CreateDatabaseConnectionString(database_name, storage))
2018-04-13 17:19:50 +08:00
{
Database = { AutoTransactionsEnabled = false }
};
2018-04-13 17:19:50 +08:00
public void ResetDatabase()
{
lock (writeLock)
{
recycleThreadContexts();
2019-12-12 13:04:57 +08:00
try
{
storage.Delete(database_name);
2019-12-12 13:04:57 +08:00
}
catch
{
// for now we are not sure why file handles are kept open by EF, but this is generally only used in testing
}
2018-04-13 17:19:50 +08:00
}
}
2020-05-11 20:37:07 +08:00
public void FlushConnections()
{
if (threadContexts != null)
{
foreach (var context in threadContexts.Values)
context.Dispose();
}
2020-05-11 20:37:07 +08:00
recycleThreadContexts();
}
public static string CreateDatabaseConnectionString(string filename, Storage storage) => string.Concat("Data Source=", storage.GetFullPath($@"{filename}", true));
2018-04-13 17:19:50 +08:00
}
}