h1or4dme8/osu-lazer
1
0
Fork 0
mirror of https://github.com/ppy/osu.git synced 2024-12-14 18:42:56 +08:00
Code Issues Releases Wiki Activity

Merge branch 'master' into realm-migration-ui

Browse Source
This commit is contained in:
Bartłomiej Dach 2022-01-22 13:52:19 +01:00
commit 1b2cca4a0d
No known key found for this signature in database
GPG Key ID: BCECCD4FA41F6497
32 changed files with 605 additions and 361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
osu.Game.Benchmarks/BenchmarkRealmReads.cs Normal file
View File

@ -0,0 +1,141 @@
// 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.
using System.Linq;
using System.Threading;
using BenchmarkDotNet.Attributes;
using osu.Framework.Testing;
using osu.Framework.Threading;
using osu.Game.Beatmaps;
using osu.Game.Database;
using osu.Game.Rulesets.Osu;
using osu.Game.Tests.Resources;
namespace osu.Game.Benchmarks
{
public class BenchmarkRealmReads : BenchmarkTest
{
private TemporaryNativeStorage storage;
private RealmContextFactory realmFactory;
private UpdateThread updateThread;
[Params(1, 100, 1000)]
public int ReadsPerFetch { get; set; }
public override void SetUp()
{
storage = new TemporaryNativeStorage("realm-benchmark");
storage.DeleteDirectory(string.Empty);
realmFactory = new RealmContextFactory(storage, "client");
realmFactory.Run(realm =>
{
realm.Write(c => c.Add(TestResources.CreateTestBeatmapSetInfo(rulesets: new[] { new OsuRuleset().RulesetInfo })));
});
updateThread = new UpdateThread(() => { }, null);
updateThread.Start();
}
[Benchmark]
public void BenchmarkDirectPropertyRead()
{
realmFactory.Run(realm =>
{
var beatmapSet = realm.All<BeatmapSetInfo>().First();
for (int i = 0; i < ReadsPerFetch; i++)
{
string _ = beatmapSet.Beatmaps.First().Hash;
}
});
}
[Benchmark]
public void BenchmarkDirectPropertyReadUpdateThread()
{
var done = new ManualResetEventSlim();
updateThread.Scheduler.Add(() =>
{
try
{
var beatmapSet = realmFactory.Context.All<BeatmapSetInfo>().First();
for (int i = 0; i < ReadsPerFetch; i++)
{
string _ = beatmapSet.Beatmaps.First().Hash;
}
}
finally
{
done.Set();
}
});
done.Wait();
}
[Benchmark]
public void BenchmarkRealmLivePropertyRead()
{
realmFactory.Run(realm =>
{
var beatmapSet = realm.All<BeatmapSetInfo>().First().ToLive(realmFactory);
for (int i = 0; i < ReadsPerFetch; i++)
{
string _ = beatmapSet.PerformRead(b => b.Beatmaps.First().Hash);
}
});
}
[Benchmark]
public void BenchmarkRealmLivePropertyReadUpdateThread()
{
var done = new ManualResetEventSlim();
updateThread.Scheduler.Add(() =>
{
try
{
var beatmapSet = realmFactory.Context.All<BeatmapSetInfo>().First().ToLive(realmFactory);
for (int i = 0; i < ReadsPerFetch; i++)
{
string _ = beatmapSet.PerformRead(b => b.Beatmaps.First().Hash);
}
}
finally
{
done.Set();
}
});
done.Wait();
}
[Benchmark]
public void BenchmarkDetachedPropertyRead()
{
realmFactory.Run(realm =>
{
var beatmapSet = realm.All<BeatmapSetInfo>().First().Detach();
for (int i = 0; i < ReadsPerFetch; i++)
{
string _ = beatmapSet.Beatmaps.First().Hash;
}
});
}
[GlobalCleanup]
public void Cleanup()
{
realmFactory?.Dispose();
storage?.Dispose();
updateThread?.Exit();
}
}
}

3
osu.Game.Tests/Beatmaps/IO/BeatmapImportHelper.cs
View File

@ -55,8 +55,7 @@ namespace osu.Game.Tests.Beatmaps.IO
{
var realmContextFactory = osu.Dependencies.Get<RealmContextFactory>();
using (var realm = realmContextFactory.CreateContext())
BeatmapImporterTests.EnsureLoaded(realm, timeout);
realmContextFactory.Run(realm => BeatmapImporterTests.EnsureLoaded(realm, timeout));
// TODO: add back some extra checks outside of the realm ones?
// var set = queryBeatmapSets().First();

20
osu.Game.Tests/Database/GeneralUsageTests.cs
View File

@ -21,7 +21,7 @@ namespace osu.Game.Tests.Database
[Test]
public void TestConstructRealm()
{
RunTestWithRealm((realmFactory, _) => { realmFactory.CreateContext().Refresh(); });
RunTestWithRealm((realmFactory, _) => { realmFactory.Run(realm => realm.Refresh()); });
}
[Test]
@ -46,23 +46,21 @@ namespace osu.Game.Tests.Database
{
bool callbackRan = false;
using (var context = realmFactory.CreateContext())
realmFactory.Run(realm =>
{
var subscription = context.All<BeatmapInfo>().QueryAsyncWithNotifications((sender, changes, error) =>
var subscription = realm.All<BeatmapInfo>().QueryAsyncWithNotifications((sender, changes, error) =>
{
using (realmFactory.CreateContext())
realmFactory.Run(_ =>
{
callbackRan = true;
}
});
});
// Force the callback above to run.
using (realmFactory.CreateContext())
{
}
realmFactory.Run(r => r.Refresh());
subscription?.Dispose();
}
});
Assert.IsTrue(callbackRan);
});
@ -78,12 +76,12 @@ namespace osu.Game.Tests.Database
Task.Factory.StartNew(() =>
{
using (realmFactory.CreateContext())
realmFactory.Run(_ =>
{
hasThreadedUsage.Set();
stopThreadedUsage.Wait();
}
});
}, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler);
hasThreadedUsage.Wait();

60
osu.Game.Tests/Database/RealmLiveTests.cs
View File

@ -23,9 +23,9 @@ namespace osu.Game.Tests.Database
{
RunTestWithRealm((realmFactory, _) =>
{
ILive<BeatmapInfo> beatmap = realmFactory.CreateContext().Write(r => r.Add(new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata()))).ToLive(realmFactory);
ILive<BeatmapInfo> beatmap = realmFactory.Run(realm => realm.Write(r => r.Add(new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata()))).ToLive(realmFactory));
ILive<BeatmapInfo> beatmap2 = realmFactory.CreateContext().All<BeatmapInfo>().First().ToLive(realmFactory);
ILive<BeatmapInfo> beatmap2 = realmFactory.Run(realm => realm.All<BeatmapInfo>().First().ToLive(realmFactory));
Assert.AreEqual(beatmap, beatmap2);
});
@ -38,13 +38,18 @@ namespace osu.Game.Tests.Database
{
var beatmap = new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata());
ILive<BeatmapInfo> liveBeatmap;
ILive<BeatmapInfo>? liveBeatmap = null;
using (var context = realmFactory.CreateContext())
realmFactory.Run(realm =>
{
context.Write(r => r.Add(beatmap));
realm.Write(r => r.Add(beatmap));
liveBeatmap = beatmap.ToLive(realmFactory);
});
using (realmFactory.BlockAllOperations())
{
// recycle realm before migrating
}
using (var migratedStorage = new TemporaryNativeStorage("realm-test-migration-target"))
@ -53,7 +58,7 @@ namespace osu.Game.Tests.Database
storage.Migrate(migratedStorage);
Assert.IsFalse(liveBeatmap.PerformRead(l => l.Hidden));
Assert.IsFalse(liveBeatmap?.PerformRead(l => l.Hidden));
}
});
}
@ -67,8 +72,7 @@ namespace osu.Game.Tests.Database
var liveBeatmap = beatmap.ToLive(realmFactory);
using (var context = realmFactory.CreateContext())
context.Write(r => r.Add(beatmap));
realmFactory.Run(realm => realm.Write(r => r.Add(beatmap)));
Assert.IsFalse(liveBeatmap.PerformRead(l => l.Hidden));
});
@ -99,12 +103,12 @@ namespace osu.Game.Tests.Database
ILive<BeatmapInfo>? liveBeatmap = null;
Task.Factory.StartNew(() =>
{
using (var threadContext = realmFactory.CreateContext())
realmFactory.Run(threadContext =>
{
var beatmap = threadContext.Write(r => r.Add(new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata())));
liveBeatmap = beatmap.ToLive(realmFactory);
}
});
}, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
Debug.Assert(liveBeatmap != null);
@ -128,12 +132,12 @@ namespace osu.Game.Tests.Database
ILive<BeatmapInfo>? liveBeatmap = null;
Task.Factory.StartNew(() =>
{
using (var threadContext = realmFactory.CreateContext())
realmFactory.Run(threadContext =>
{
var beatmap = threadContext.Write(r => r.Add(new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata())));
liveBeatmap = beatmap.ToLive(realmFactory);
}
});
}, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
Debug.Assert(liveBeatmap != null);
@ -170,12 +174,12 @@ namespace osu.Game.Tests.Database
Task.Factory.StartNew(() =>
{
using (var threadContext = realmFactory.CreateContext())
realmFactory.Run(threadContext =>
{
var beatmap = threadContext.Write(r => r.Add(new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata())));
liveBeatmap = beatmap.ToLive(realmFactory);
}
});
}, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
Debug.Assert(liveBeatmap != null);
@ -189,13 +193,13 @@ namespace osu.Game.Tests.Database
});
// Can't be used, even from within a valid context.
using (realmFactory.CreateContext())
realmFactory.Run(threadContext =>
{
Assert.Throws<InvalidOperationException>(() =>
{
var __ = liveBeatmap.Value;
});
}
});
}, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
});
}
@ -208,12 +212,12 @@ namespace osu.Game.Tests.Database
ILive<BeatmapInfo>? liveBeatmap = null;
Task.Factory.StartNew(() =>
{
using (var threadContext = realmFactory.CreateContext())
realmFactory.Run(threadContext =>
{
var beatmap = threadContext.Write(r => r.Add(new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata())));
liveBeatmap = beatmap.ToLive(realmFactory);
}
});
}, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
Debug.Assert(liveBeatmap != null);
@ -235,50 +239,50 @@ namespace osu.Game.Tests.Database
{
int changesTriggered = 0;
using (var updateThreadContext = realmFactory.CreateContext())
realmFactory.Run(outerRealm =>
{
updateThreadContext.All<BeatmapInfo>().QueryAsyncWithNotifications(gotChange);
outerRealm.All<BeatmapInfo>().QueryAsyncWithNotifications(gotChange);
ILive<BeatmapInfo>? liveBeatmap = null;
Task.Factory.StartNew(() =>
{
using (var threadContext = realmFactory.CreateContext())
realmFactory.Run(innerRealm =>
{
var ruleset = CreateRuleset();
var beatmap = threadContext.Write(r => r.Add(new BeatmapInfo(ruleset, new BeatmapDifficulty(), new BeatmapMetadata())));
var beatmap = innerRealm.Write(r => r.Add(new BeatmapInfo(ruleset, new BeatmapDifficulty(), new BeatmapMetadata())));
// add a second beatmap to ensure that a full refresh occurs below.
// not just a refresh from the resolved Live.
threadContext.Write(r => r.Add(new BeatmapInfo(ruleset, new BeatmapDifficulty(), new BeatmapMetadata())));
innerRealm.Write(r => r.Add(new BeatmapInfo(ruleset, new BeatmapDifficulty(), new BeatmapMetadata())));
liveBeatmap = beatmap.ToLive(realmFactory);
}
});
}, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
Debug.Assert(liveBeatmap != null);
// not yet seen by main context
Assert.AreEqual(0, updateThreadContext.All<BeatmapInfo>().Count());
Assert.AreEqual(0, outerRealm.All<BeatmapInfo>().Count());
Assert.AreEqual(0, changesTriggered);
liveBeatmap.PerformRead(resolved =>
{
// retrieval causes an implicit refresh. even changes that aren't related to the retrieval are fired at this point.
// ReSharper disable once AccessToDisposedClosure
Assert.AreEqual(2, updateThreadContext.All<BeatmapInfo>().Count());
Assert.AreEqual(2, outerRealm.All<BeatmapInfo>().Count());
Assert.AreEqual(1, changesTriggered);
// can access properties without a crash.
Assert.IsFalse(resolved.Hidden);
// ReSharper disable once AccessToDisposedClosure
updateThreadContext.Write(r =>
outerRealm.Write(r =>
{
// can use with the main context.
r.Remove(resolved);
});
});
}
});
void gotChange(IRealmCollection<BeatmapInfo> sender, ChangeSet changes, Exception error)
{

27
osu.Game.Tests/Database/TestRealmKeyBindingStore.cs
View File

@ -60,15 +60,12 @@ namespace osu.Game.Tests.Database
KeyBindingContainer testContainer = new TestKeyBindingContainer();
// Add some excess bindings for an action which only supports 1.
using (var realm = realmContextFactory.CreateContext())
using (var transaction = realm.BeginWrite())
realmContextFactory.Write(realm =>
{
realm.Add(new RealmKeyBinding(GlobalAction.Back, new KeyCombination(InputKey.A)));
realm.Add(new RealmKeyBinding(GlobalAction.Back, new KeyCombination(InputKey.S)));
realm.Add(new RealmKeyBinding(GlobalAction.Back, new KeyCombination(InputKey.D)));
transaction.Commit();
}
});
Assert.That(queryCount(GlobalAction.Back), Is.EqualTo(3));
@ -79,13 +76,13 @@ namespace osu.Game.Tests.Database
private int queryCount(GlobalAction? match = null)
{
using (var realm = realmContextFactory.CreateContext())
return realmContextFactory.Run(realm =>
{
var results = realm.All<RealmKeyBinding>();
if (match.HasValue)
results = results.Where(k => k.ActionInt == (int)match.Value);
return results.Count();
}
});
}
[Test]
@ -95,26 +92,26 @@ namespace osu.Game.Tests.Database
keyBindingStore.Register(testContainer, Enumerable.Empty<RulesetInfo>());
using (var primaryRealm = realmContextFactory.CreateContext())
realmContextFactory.Run(outerRealm =>
{
var backBinding = primaryRealm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
var backBinding = outerRealm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.Escape }));
var tsr = ThreadSafeReference.Create(backBinding);
using (var threadedContext = realmContextFactory.CreateContext())
realmContextFactory.Run(innerRealm =>
{
var binding = threadedContext.ResolveReference(tsr);
threadedContext.Write(() => binding.KeyCombination = new KeyCombination(InputKey.BackSpace));
}
var binding = innerRealm.ResolveReference(tsr);
innerRealm.Write(() => binding.KeyCombination = new KeyCombination(InputKey.BackSpace));
});
Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.BackSpace }));
// check still correct after re-query.
backBinding = primaryRealm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
backBinding = outerRealm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.BackSpace }));
}
});
}
[TearDown]

4
osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs
View File

@ -60,8 +60,8 @@ namespace osu.Game.Tests.Online
testBeatmapInfo = getTestBeatmapInfo(testBeatmapFile);
testBeatmapSet = testBeatmapInfo.BeatmapSet;
ContextFactory.Context.Write(r => r.RemoveAll<BeatmapSetInfo>());
ContextFactory.Context.Write(r => r.RemoveAll<BeatmapInfo>());
ContextFactory.Write(r => r.RemoveAll<BeatmapSetInfo>());
ContextFactory.Write(r => r.RemoveAll<BeatmapInfo>());
selectedItem.Value = new PlaylistItem
{

4
osu.Game.Tests/Visual/Ranking/TestSceneResultsScreen.cs
View File

@ -42,7 +42,7 @@ namespace osu.Game.Tests.Visual.Ranking
{
base.LoadComplete();
using (var realm = realmContextFactory.CreateContext())
realmContextFactory.Run(realm =>
{
var beatmapInfo = realm.All<BeatmapInfo>()
.Filter($"{nameof(BeatmapInfo.Ruleset)}.{nameof(RulesetInfo.OnlineID)} = $0", 0)
@ -50,7 +50,7 @@ namespace osu.Game.Tests.Visual.Ranking
if (beatmapInfo != null)
Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmapInfo);
}
});
}
[Test]

4
osu.Game.Tests/Visual/UserInterface/TestSceneDeleteLocalScore.cs
View File

@ -122,11 +122,11 @@ namespace osu.Game.Tests.Visual.UserInterface
[SetUp]
public void Setup() => Schedule(() =>
{
using (var realm = realmFactory.CreateContext())
realmFactory.Run(realm =>
{
// Due to soft deletions, we can re-use deleted scores between test runs
scoreManager.Undelete(realm.All<ScoreInfo>().Where(s => s.DeletePending).ToList());
}
});
leaderboard.Scores = null;
leaderboard.FinishTransforms(true); // After setting scores, we may be waiting for transforms to expire drawables

69
osu.Game/Beatmaps/BeatmapManager.cs
View File

@ -119,15 +119,17 @@ namespace osu.Game.Beatmaps
/// <param name="beatmapInfo">The beatmap difficulty to hide.</param>
public void Hide(BeatmapInfo beatmapInfo)
{
using (var realm = contextFactory.CreateContext())
using (var transaction = realm.BeginWrite())
contextFactory.Run(realm =>
{
if (!beatmapInfo.IsManaged)
beatmapInfo = realm.Find<BeatmapInfo>(beatmapInfo.ID);
using (var transaction = realm.BeginWrite())
{
if (!beatmapInfo.IsManaged)
beatmapInfo = realm.Find<BeatmapInfo>(beatmapInfo.ID);
beatmapInfo.Hidden = true;
transaction.Commit();
}
beatmapInfo.Hidden = true;
transaction.Commit();
}
});
}
/// <summary>
@ -136,27 +138,31 @@ namespace osu.Game.Beatmaps
/// <param name="beatmapInfo">The beatmap difficulty to restore.</param>
public void Restore(BeatmapInfo beatmapInfo)
{
using (var realm = contextFactory.CreateContext())
using (var transaction = realm.BeginWrite())
contextFactory.Run(realm =>
{
if (!beatmapInfo.IsManaged)
beatmapInfo = realm.Find<BeatmapInfo>(beatmapInfo.ID);
using (var transaction = realm.BeginWrite())
{
if (!beatmapInfo.IsManaged)
beatmapInfo = realm.Find<BeatmapInfo>(beatmapInfo.ID);
beatmapInfo.Hidden = false;
transaction.Commit();
}
beatmapInfo.Hidden = false;
transaction.Commit();
}
});
}
public void RestoreAll()
{
using (var realm = contextFactory.CreateContext())
using (var transaction = realm.BeginWrite())
contextFactory.Run(realm =>
{
foreach (var beatmap in realm.All<BeatmapInfo>().Where(b => b.Hidden))
beatmap.Hidden = false;
using (var transaction = realm.BeginWrite())
{
foreach (var beatmap in realm.All<BeatmapInfo>().Where(b => b.Hidden))
beatmap.Hidden = false;
transaction.Commit();
}
transaction.Commit();
}
});
}
/// <summary>
@ -165,8 +171,11 @@ namespace osu.Game.Beatmaps
/// <returns>A list of available <see cref="BeatmapSetInfo"/>.</returns>
public List<BeatmapSetInfo> GetAllUsableBeatmapSets()
{
using (var context = contextFactory.CreateContext())
return context.All<BeatmapSetInfo>().Where(b => !b.DeletePending).Detach();
return contextFactory.Run(realm =>
{
realm.Refresh();
return realm.All<BeatmapSetInfo>().Where(b => !b.DeletePending).Detach();
});
}
/// <summary>
@ -176,8 +185,7 @@ namespace osu.Game.Beatmaps
/// <returns>The first result for the provided query, or null if no results were found.</returns>
public ILive<BeatmapSetInfo>? QueryBeatmapSet(Expression<Func<BeatmapSetInfo, bool>> query)
{
using (var context = contextFactory.CreateContext())
return context.All<BeatmapSetInfo>().FirstOrDefault(query)?.ToLive(contextFactory);
return contextFactory.Run(realm => realm.All<BeatmapSetInfo>().FirstOrDefault(query)?.ToLive(contextFactory));
}
#region Delegation to BeatmapModelManager (methods which previously existed locally).
@ -232,21 +240,20 @@ namespace osu.Game.Beatmaps
public void Delete(Expression<Func<BeatmapSetInfo, bool>>? filter = null, bool silent = false)
{
using (var context = contextFactory.CreateContext())
contextFactory.Run(realm =>
{
var items = context.All<BeatmapSetInfo>().Where(s => !s.DeletePending && !s.Protected);
var items = realm.All<BeatmapSetInfo>().Where(s => !s.DeletePending && !s.Protected);
if (filter != null)
items = items.Where(filter);
beatmapModelManager.Delete(items.ToList(), silent);
}
});
}
public void UndeleteAll()
{
using (var context = contextFactory.CreateContext())
beatmapModelManager.Undelete(context.All<BeatmapSetInfo>().Where(s => s.DeletePending).ToList());
contextFactory.Run(realm => beatmapModelManager.Undelete(realm.All<BeatmapSetInfo>().Where(s => s.DeletePending).ToList()));
}
public void Undelete(List<BeatmapSetInfo> items, bool silent = false)
@ -305,13 +312,13 @@ namespace osu.Game.Beatmaps
// If we seem to be missing files, now is a good time to re-fetch.
if (importedBeatmap?.BeatmapSet?.Files.Count == 0)
{
using (var realm = contextFactory.CreateContext())
contextFactory.Run(realm =>
{
var refetch = realm.Find<BeatmapInfo>(importedBeatmap.ID)?.Detach();
if (refetch != null)
importedBeatmap = refetch;
}
});
}
return workingBeatmapCache.GetWorkingBeatmap(importedBeatmap);

9
osu.Game/Beatmaps/BeatmapModelManager.cs
View File

@ -98,17 +98,16 @@ namespace osu.Game.Beatmaps
/// <returns>The first result for the provided query, or null if no results were found.</returns>
public BeatmapInfo? QueryBeatmap(Expression<Func<BeatmapInfo, bool>> query)
{
using (var context = ContextFactory.CreateContext())
return context.All<BeatmapInfo>().FirstOrDefault(query)?.Detach();
return ContextFactory.Run(realm => realm.All<BeatmapInfo>().FirstOrDefault(query)?.Detach());
}
public void Update(BeatmapSetInfo item)
{
using (var realm = ContextFactory.CreateContext())
ContextFactory.Write(realm =>
{
var existing = realm.Find<BeatmapSetInfo>(item.ID);
realm.Write(r => item.CopyChangesToRealm(existing));
}
item.CopyChangesToRealm(existing);
});
}
}
}

105
osu.Game/Database/EFToRealmMigrator.cs
View File

@ -8,7 +8,6 @@ using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Logging;
using osu.Framework.Platform;
using osu.Game.Beatmaps;
using osu.Game.Configuration;
using osu.Game.Graphics;
@ -142,7 +141,7 @@ namespace osu.Game.Database
int count = existingBeatmapSets.Count();
using (var realm = realmContextFactory.CreateContext())
realmContextFactory.Run(realm =>
{
log($"Found {count} beatmaps in EF");
@ -227,7 +226,7 @@ namespace osu.Game.Database
log($"Successfully migrated {count} beatmaps to realm");
}
}
});
}
private BeatmapMetadata getBestMetadata(EFBeatmapMetadata? beatmapMetadata, EFBeatmapMetadata? beatmapSetMetadata)
@ -273,7 +272,7 @@ namespace osu.Game.Database
int count = existingScores.Count();
using (var realm = realmContextFactory.CreateContext())
realmContextFactory.Run(realm =>
{
log($"Found {count} scores in EF");
@ -341,7 +340,7 @@ namespace osu.Game.Database
log($"Successfully migrated {count} scores to realm");
}
}
});
}
private void migrateSkins(OsuDbContext db)
@ -370,37 +369,39 @@ namespace osu.Game.Database
break;
}
using (var realm = realmContextFactory.CreateContext())
using (var transaction = realm.BeginWrite())
realmContextFactory.Run(realm =>
{
// only migrate data if the realm database is empty.
// note that this cannot be written as: `realm.All<SkinInfo>().All(s => s.Protected)`, because realm does not support `.All()`.
if (!realm.All<SkinInfo>().Any(s => !s.Protected))
using (var transaction = realm.BeginWrite())
{
log($"Migrating {existingSkins.Count} skins");
foreach (var skin in existingSkins)
// only migrate data if the realm database is empty.
// note that this cannot be written as: `realm.All<SkinInfo>().All(s => s.Protected)`, because realm does not support `.All()`.
if (!realm.All<SkinInfo>().Any(s => !s.Protected))
{
var realmSkin = new SkinInfo
log($"Migrating {existingSkins.Count} skins");
foreach (var skin in existingSkins)
{
Name = skin.Name,
Creator = skin.Creator,
Hash = skin.Hash,
Protected = false,
InstantiationInfo = skin.InstantiationInfo,
};
var realmSkin = new SkinInfo
{
Name = skin.Name,
Creator = skin.Creator,
Hash = skin.Hash,
Protected = false,
InstantiationInfo = skin.InstantiationInfo,
};
migrateFiles(skin, realm, realmSkin);
migrateFiles(skin, realm, realmSkin);
realm.Add(realmSkin);
realm.Add(realmSkin);
if (skin.ID == userSkinInt)
userSkinChoice.Value = realmSkin.ID.ToString();
if (skin.ID == userSkinInt)
userSkinChoice.Value = realmSkin.ID.ToString();
}
}
}
transaction.Commit();
}
transaction.Commit();
}
});
}
private static void migrateFiles<T>(IHasFiles<T> fileSource, Realm realm, IHasRealmFiles realmObject) where T : INamedFileInfo
@ -427,36 +428,38 @@ namespace osu.Game.Database
log("Beginning settings migration to realm");
using (var realm = realmContextFactory.CreateContext())
using (var transaction = realm.BeginWrite())
realmContextFactory.Run(realm =>
{
// only migrate data if the realm database is empty.
if (!realm.All<RealmRulesetSetting>().Any())
using (var transaction = realm.BeginWrite())
{
log($"Migrating {existingSettings.Count} settings");
foreach (var dkb in existingSettings)
// only migrate data if the realm database is empty.
if (!realm.All<RealmRulesetSetting>().Any())
{
if (dkb.RulesetID == null)
continue;
log($"Migrating {existingSettings.Count} settings");
string? shortName = getRulesetShortNameFromLegacyID(dkb.RulesetID.Value);
if (string.IsNullOrEmpty(shortName))
continue;
realm.Add(new RealmRulesetSetting
foreach (var dkb in existingSettings)
{
Key = dkb.Key,
Value = dkb.StringValue,
RulesetName = shortName,
Variant = dkb.Variant ?? 0,
});
}
}
if (dkb.RulesetID == null)
continue;
transaction.Commit();
}
string? shortName = getRulesetShortNameFromLegacyID(dkb.RulesetID.Value);
if (string.IsNullOrEmpty(shortName))
continue;
realm.Add(new RealmRulesetSetting
{
Key = dkb.Key,
Value = dkb.StringValue,
RulesetName = shortName,
Variant = dkb.Variant ?? 0,
});
}
}
transaction.Commit();
}
});
}
private string? getRulesetShortNameFromLegacyID(long rulesetId) =>

20
osu.Game/Database/IRealmFactory.cs
View File

@ -1,20 +0,0 @@
// 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.
using Realms;
namespace osu.Game.Database
{
public interface IRealmFactory
{
/// <summary>
/// The main realm context, bound to the update thread.
/// </summary>
Realm Context { get; }
/// <summary>
/// Create a new realm context for use on the current thread.
/// </summary>
Realm CreateContext();
}
}

63
osu.Game/Database/RealmContextFactory.cs
View File

@ -30,7 +30,7 @@ namespace osu.Game.Database
/// <summary>
/// A factory which provides both the main (update thread bound) realm context and creates contexts for async usage.
/// </summary>
public class RealmContextFactory : IDisposable, IRealmFactory
public class RealmContextFactory : IDisposable
{
private readonly Storage storage;
@ -72,13 +72,13 @@ namespace osu.Game.Database
get
{
if (!ThreadSafety.IsUpdateThread)
throw new InvalidOperationException(@$"Use {nameof(CreateContext)} when performing realm operations from a non-update thread");
throw new InvalidOperationException(@$"Use {nameof(Run)}/{nameof(Write)} when performing realm operations from a non-update thread");
lock (contextLock)
{
if (context == null)
{
context = CreateContext();
context = createContext();
Logger.Log(@$"Opened realm ""{context.Config.DatabasePath}"" at version {context.Config.SchemaVersion}");
}
@ -124,7 +124,7 @@ namespace osu.Game.Database
private void cleanupPendingDeletions()
{
using (var realm = CreateContext())
using (var realm = createContext())
using (var transaction = realm.BeginWrite())
{
var pendingDeleteScores = realm.All<ScoreInfo>().Where(s => s.DeletePending);
@ -169,7 +169,60 @@ namespace osu.Game.Database
/// <returns></returns>
public bool Compact() => Realm.Compact(getConfiguration());
public Realm CreateContext()
/// <summary>
/// Run work on realm with a return value.
/// </summary>
/// <remarks>
/// Handles correct context management automatically.
/// </remarks>
/// <param name="action">The work to run.</param>
/// <typeparam name="T">The return type.</typeparam>
public T Run<T>(Func<Realm, T> action)
{
if (ThreadSafety.IsUpdateThread)
return action(Context);
using (var realm = createContext())
return action(realm);
}
/// <summary>
/// Run work on realm.
/// </summary>
/// <remarks>
/// Handles correct context management automatically.
/// </remarks>
/// <param name="action">The work to run.</param>
public void Run(Action<Realm> action)
{
if (ThreadSafety.IsUpdateThread)
action(Context);
else
{
using (var realm = createContext())
action(realm);
}
}
/// <summary>
/// Write changes to realm.
/// </summary>
/// <remarks>
/// Handles correct context management and transaction committing automatically.
/// </remarks>
/// <param name="action">The work to run.</param>
public void Write(Action<Realm> action)
{
if (ThreadSafety.IsUpdateThread)
Context.Write(action);
else
{
using (var realm = createContext())
realm.Write(action);
}
}
private Realm createContext()
{
if (isDisposed)
throw new ObjectDisposedException(nameof(RealmContextFactory));

28
osu.Game/Database/RealmLive.cs
View File

@ -51,8 +51,10 @@ namespace osu.Game.Database
return;
}
using (var realm = realmFactory.CreateContext())
perform(realm.Find<T>(ID));
realmFactory.Run(realm =>
{
perform(retrieveFromID(realm, ID));
});
}
/// <summary>
@ -64,15 +66,15 @@ namespace osu.Game.Database
if (!IsManaged)
return perform(data);
using (var realm = realmFactory.CreateContext())
return realmFactory.Run(realm =>
{
var returnData = perform(realm.Find<T>(ID));
var returnData = perform(retrieveFromID(realm, ID));
if (returnData is RealmObjectBase realmObject && realmObject.IsManaged)
throw new InvalidOperationException(@$"Managed realm objects should not exit the scope of {nameof(PerformRead)}.");
return returnData;
}
});
}
/// <summary>
@ -106,6 +108,22 @@ namespace osu.Game.Database
}
}
private T retrieveFromID(Realm realm, Guid id)
{
var found = realm.Find<T>(ID);
if (found == null)
{
// It may be that we access this from the update thread before a refresh has taken place.
// To ensure that behaviour matches what we'd expect (the object *is* available), force
// a refresh to bring in any off-thread changes immediately.
realm.Refresh();
found = realm.Find<T>(ID);
}
return found;
}
public bool Equals(ILive<T>? other) => ID == other?.ID;
public override string ToString() => PerformRead(i => i.ToString());

3
osu.Game/Database/RealmLiveUnmanaged.cs
View File

@ -21,6 +21,9 @@ namespace osu.Game.Database
/// <param name="data">The realm data.</param>
public RealmLiveUnmanaged(T data)
{
if (data.IsManaged)
throw new InvalidOperationException($"Cannot use {nameof(RealmLiveUnmanaged<T>)} with managed instances");
Value = data;
}

36
osu.Game/Input/RealmKeyBindingStore.cs
View File

@ -34,7 +34,7 @@ namespace osu.Game.Input
{
List<string> combinations = new List<string>();
using (var context = realmFactory.CreateContext())
realmFactory.Run(context =>
{
foreach (var action in context.All<RealmKeyBinding>().Where(b => string.IsNullOrEmpty(b.RulesetName) && (GlobalAction)b.ActionInt == globalAction))
{
@ -44,7 +44,7 @@ namespace osu.Game.Input
if (str.Length > 0)
combinations.Add(str);
}
}
});
return combinations;
}
@ -56,24 +56,26 @@ namespace osu.Game.Input
/// <param name="rulesets">The rulesets to populate defaults from.</param>
public void Register(KeyBindingContainer container, IEnumerable<RulesetInfo> rulesets)
{
using (var realm = realmFactory.CreateContext())
using (var transaction = realm.BeginWrite())
realmFactory.Run(realm =>
{
// intentionally flattened to a list rather than querying against the IQueryable, as nullable fields being queried against aren't indexed.
// this is much faster as a result.
var existingBindings = realm.All<RealmKeyBinding>().ToList();
insertDefaults(realm, existingBindings, container.DefaultKeyBindings);
foreach (var ruleset in rulesets)
using (var transaction = realm.BeginWrite())
{
var instance = ruleset.CreateInstance();
foreach (int variant in instance.AvailableVariants)
insertDefaults(realm, existingBindings, instance.GetDefaultKeyBindings(variant), ruleset.ShortName, variant);
}
// intentionally flattened to a list rather than querying against the IQueryable, as nullable fields being queried against aren't indexed.
// this is much faster as a result.
var existingBindings = realm.All<RealmKeyBinding>().ToList();
transaction.Commit();
}
insertDefaults(realm, existingBindings, container.DefaultKeyBindings);
foreach (var ruleset in rulesets)
{
var instance = ruleset.CreateInstance();
foreach (int variant in instance.AvailableVariants)
insertDefaults(realm, existingBindings, instance.GetDefaultKeyBindings(variant), ruleset.ShortName, variant);
}
transaction.Commit();
}
});
}
private void insertDefaults(Realm realm, List<RealmKeyBinding> existingBindings, IEnumerable<IKeyBinding> defaults, string? rulesetName = null, int? variant = null)

4
osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow.cs
View File

@ -386,11 +386,11 @@ namespace osu.Game.Overlays.Settings.Sections.Input
private void updateStoreFromButton(KeyButton button)
{
using (var realm = realmFactory.CreateContext())
realmFactory.Run(realm =>
{
var binding = realm.Find<RealmKeyBinding>(((IHasGuidPrimaryKey)button.KeyBinding).ID);
realm.Write(() => binding.KeyCombinationString = button.KeyBinding.KeyCombinationString);
}
});
}
private void updateIsDefaultValue()

7
osu.Game/Overlays/Settings/Sections/Input/KeyBindingsSubsection.cs
View File

@ -34,10 +34,9 @@ namespace osu.Game.Overlays.Settings.Sections.Input
{
string rulesetName = Ruleset?.ShortName;
List<RealmKeyBinding> bindings;
using (var realm = realmFactory.CreateContext())
bindings = realm.All<RealmKeyBinding>().Where(b => b.RulesetName == rulesetName && b.Variant == variant).Detach();
var bindings = realmFactory.Run(realm => realm.All<RealmKeyBinding>()
.Where(b => b.RulesetName == rulesetName && b.Variant == variant)
.Detach());
foreach (var defaultGroup in Defaults.GroupBy(d => d.Action))
{

18
osu.Game/Rulesets/Configuration/RulesetConfigManager.cs
View File

@ -56,21 +56,15 @@ namespace osu.Game.Rulesets.Configuration
pendingWrites.Clear();
}
if (realmFactory == null)
return true;
using (var context = realmFactory.CreateContext())
realmFactory?.Write(realm =>
{
context.Write(realm =>
foreach (var c in changed)
{
foreach (var c in changed)
{
var setting = realm.All<RealmRulesetSetting>().First(s => s.RulesetName == rulesetName && s.Variant == variant && s.Key == c.ToString());
var setting = realm.All<RealmRulesetSetting>().First(s => s.RulesetName == rulesetName && s.Variant == variant && s.Key == c.ToString());
setting.Value = ConfigStore[c].ToString();
}
});
}
setting.Value = ConfigStore[c].ToString();
}
});
return true;
}

107
osu.Game/Rulesets/RulesetStore.cs
View File

@ -100,74 +100,71 @@ namespace osu.Game.Rulesets
private void addMissingRulesets()
{
using (var context = realmFactory.CreateContext())
realmFactory.Write(realm =>
{
context.Write(realm =>
var rulesets = realm.All<RulesetInfo>();
List<Ruleset> instances = loadedAssemblies.Values
.Select(r => Activator.CreateInstance(r) as Ruleset)
.Where(r => r != null)
.Select(r => r.AsNonNull())
.ToList();
// add all legacy rulesets first to ensure they have exclusive choice of primary key.
foreach (var r in instances.Where(r => r is ILegacyRuleset))
{
var rulesets = realm.All<RulesetInfo>();
if (realm.All<RulesetInfo>().FirstOrDefault(rr => rr.OnlineID == r.RulesetInfo.OnlineID) == null)
realm.Add(new RulesetInfo(r.RulesetInfo.ShortName, r.RulesetInfo.Name, r.RulesetInfo.InstantiationInfo, r.RulesetInfo.OnlineID));
}
List<Ruleset> instances = loadedAssemblies.Values
.Select(r => Activator.CreateInstance(r) as Ruleset)
.Where(r => r != null)
.Select(r => r.AsNonNull())
.ToList();
// add all legacy rulesets first to ensure they have exclusive choice of primary key.
foreach (var r in instances.Where(r => r is ILegacyRuleset))
// add any other rulesets which have assemblies present but are not yet in the database.
foreach (var r in instances.Where(r => !(r is ILegacyRuleset)))
{
if (rulesets.FirstOrDefault(ri => ri.InstantiationInfo.Equals(r.RulesetInfo.InstantiationInfo, StringComparison.Ordinal)) == null)
{
if (realm.All<RulesetInfo>().FirstOrDefault(rr => rr.OnlineID == r.RulesetInfo.OnlineID) == null)
var existingSameShortName = rulesets.FirstOrDefault(ri => ri.ShortName == r.RulesetInfo.ShortName);
if (existingSameShortName != null)
{
// even if a matching InstantiationInfo was not found, there may be an existing ruleset with the same ShortName.
// this generally means the user or ruleset provider has renamed their dll but the underlying ruleset is *likely* the same one.
// in such cases, update the instantiation info of the existing entry to point to the new one.
existingSameShortName.InstantiationInfo = r.RulesetInfo.InstantiationInfo;
}
else
realm.Add(new RulesetInfo(r.RulesetInfo.ShortName, r.RulesetInfo.Name, r.RulesetInfo.InstantiationInfo, r.RulesetInfo.OnlineID));
}
}
// add any other rulesets which have assemblies present but are not yet in the database.
foreach (var r in instances.Where(r => !(r is ILegacyRuleset)))
List<RulesetInfo> detachedRulesets = new List<RulesetInfo>();
// perform a consistency check and detach final rulesets from realm for cross-thread runtime usage.
foreach (var r in rulesets.OrderBy(r => r.OnlineID))
{
try
{
if (rulesets.FirstOrDefault(ri => ri.InstantiationInfo.Equals(r.RulesetInfo.InstantiationInfo, StringComparison.Ordinal)) == null)
{
var existingSameShortName = rulesets.FirstOrDefault(ri => ri.ShortName == r.RulesetInfo.ShortName);
var resolvedType = Type.GetType(r.InstantiationInfo)
?? throw new RulesetLoadException(@"Type could not be resolved");
if (existingSameShortName != null)
{
// even if a matching InstantiationInfo was not found, there may be an existing ruleset with the same ShortName.
// this generally means the user or ruleset provider has renamed their dll but the underlying ruleset is *likely* the same one.
// in such cases, update the instantiation info of the existing entry to point to the new one.
existingSameShortName.InstantiationInfo = r.RulesetInfo.InstantiationInfo;
}
else
realm.Add(new RulesetInfo(r.RulesetInfo.ShortName, r.RulesetInfo.Name, r.RulesetInfo.InstantiationInfo, r.RulesetInfo.OnlineID));
}
var instanceInfo = (Activator.CreateInstance(resolvedType) as Ruleset)?.RulesetInfo
?? throw new RulesetLoadException(@"Instantiation failure");
r.Name = instanceInfo.Name;
r.ShortName = instanceInfo.ShortName;
r.InstantiationInfo = instanceInfo.InstantiationInfo;
r.Available = true;
detachedRulesets.Add(r.Clone());
}
List<RulesetInfo> detachedRulesets = new List<RulesetInfo>();
// perform a consistency check and detach final rulesets from realm for cross-thread runtime usage.
foreach (var r in rulesets.OrderBy(r => r.OnlineID))
catch (Exception ex)
{
try
{
var resolvedType = Type.GetType(r.InstantiationInfo)
?? throw new RulesetLoadException(@"Type could not be resolved");
var instanceInfo = (Activator.CreateInstance(resolvedType) as Ruleset)?.RulesetInfo
?? throw new RulesetLoadException(@"Instantiation failure");
r.Name = instanceInfo.Name;
r.ShortName = instanceInfo.ShortName;
r.InstantiationInfo = instanceInfo.InstantiationInfo;
r.Available = true;
detachedRulesets.Add(r.Clone());
}
catch (Exception ex)
{
r.Available = false;
Logger.Log($"Could not load ruleset {r}: {ex.Message}");
}
r.Available = false;
Logger.Log($"Could not load ruleset {r}: {ex.Message}");
}
}
availableRulesets.AddRange(detachedRulesets);
});
}
availableRulesets.AddRange(detachedRulesets);
});
}
private void loadFromAppDomain()

11
osu.Game/Scoring/ScoreManager.cs
View File

@ -51,8 +51,7 @@ namespace osu.Game.Scoring
/// <returns>The first result for the provided query, or null if no results were found.</returns>
public ScoreInfo Query(Expression<Func<ScoreInfo, bool>> query)
{
using (var context = contextFactory.CreateContext())
return context.All<ScoreInfo>().FirstOrDefault(query)?.Detach();
return contextFactory.Run(realm => realm.All<ScoreInfo>().FirstOrDefault(query)?.Detach());
}
/// <summary>
@ -255,16 +254,16 @@ namespace osu.Game.Scoring
public void Delete([CanBeNull] Expression<Func<ScoreInfo, bool>> filter = null, bool silent = false)
{
using (var context = contextFactory.CreateContext())
contextFactory.Run(realm =>
{
var items = context.All<ScoreInfo>()
.Where(s => !s.DeletePending);
var items = realm.All<ScoreInfo>()
.Where(s => !s.DeletePending);
if (filter != null)
items = items.Where(filter);
scoreModelManager.Delete(items.ToList(), silent);
}
});
}
public void Delete(List<ScoreInfo> items, bool silent = false)

3
osu.Game/Scoring/ScoreModelManager.cs
View File

@ -74,8 +74,7 @@ namespace osu.Game.Scoring
public override bool IsAvailableLocally(ScoreInfo model)
{
using (var context = ContextFactory.CreateContext())
return context.All<ScoreInfo>().Any(b => b.OnlineID == model.OnlineID);
return ContextFactory.Run(realm => realm.All<ScoreInfo>().Any(s => s.OnlineID == model.OnlineID));
}
}
}

118
osu.Game/Screens/Select/BeatmapCarousel.cs
View File

@ -114,9 +114,10 @@ namespace osu.Game.Screens.Select
{
CarouselRoot newRoot = new CarouselRoot(this);
newRoot.AddChildren(beatmapSets.Select(createCarouselSet).Where(g => g != null));
newRoot.AddChildren(beatmapSets.Select(s => createCarouselSet(s.Detach())).Where(g => g != null));
root = newRoot;
if (selectedBeatmapSet != null && !beatmapSets.Contains(selectedBeatmapSet.BeatmapSet))
selectedBeatmapSet = null;
@ -178,8 +179,7 @@ namespace osu.Game.Screens.Select
if (!loadedTestBeatmaps)
{
using (var realm = realmFactory.CreateContext())
loadBeatmapSets(getBeatmapSets(realm));
realmFactory.Run(realm => loadBeatmapSets(getBeatmapSets(realm)));
}
}
@ -209,7 +209,7 @@ namespace osu.Game.Screens.Select
return;
foreach (int i in changes.InsertedIndices)
RemoveBeatmapSet(sender[i]);
removeBeatmapSet(sender[i].ID);
}
private void beatmapSetsChanged(IRealmCollection<BeatmapSetInfo> sender, ChangeSet changes, Exception error)
@ -223,24 +223,21 @@ namespace osu.Game.Screens.Select
// During initial population, we must manually account for the fact that our original query was done on an async thread.
// Since then, there may have been imports or deletions.
// Here we manually catch up on any changes.
var populatedSets = new HashSet<Guid>();
foreach (var s in beatmapSets)
populatedSets.Add(s.BeatmapSet.ID);
var realmSets = new HashSet<Guid>();
foreach (var s in sender)
realmSets.Add(s.ID);
foreach (var s in realmSets)
for (int i = 0; i < sender.Count; i++)
realmSets.Add(sender[i].ID);
foreach (var id in realmSets)
{
if (!populatedSets.Contains(s))
UpdateBeatmapSet(realmFactory.Context.Find<BeatmapSetInfo>(s));
if (!root.BeatmapSetsByID.ContainsKey(id))
UpdateBeatmapSet(realmFactory.Context.Find<BeatmapSetInfo>(id).Detach());
}
foreach (var s in populatedSets)
foreach (var id in root.BeatmapSetsByID.Keys)
{
if (!realmSets.Contains(s))
RemoveBeatmapSet(realmFactory.Context.Find<BeatmapSetInfo>(s));
if (!realmSets.Contains(id))
removeBeatmapSet(id);
}
signalBeatmapsLoaded();
@ -248,10 +245,10 @@ namespace osu.Game.Screens.Select
}
foreach (int i in changes.NewModifiedIndices)
UpdateBeatmapSet(sender[i]);
UpdateBeatmapSet(sender[i].Detach());
foreach (int i in changes.InsertedIndices)
UpdateBeatmapSet(sender[i]);
UpdateBeatmapSet(sender[i].Detach());
}
private void beatmapsChanged(IRealmCollection<BeatmapInfo> sender, ChangeSet changes, Exception error)
@ -261,16 +258,30 @@ namespace osu.Game.Screens.Select
return;
foreach (int i in changes.InsertedIndices)
UpdateBeatmapSet(sender[i].BeatmapSet);
{
var beatmapInfo = sender[i];
var beatmapSet = beatmapInfo.BeatmapSet;
Debug.Assert(beatmapSet != null);
// Only require to action here if the beatmap is missing.
// This avoids processing these events unnecessarily when new beatmaps are imported, for example.
if (root.BeatmapSetsByID.TryGetValue(beatmapSet.ID, out var existingSet)
&& existingSet.BeatmapSet.Beatmaps.All(b => b.ID != beatmapInfo.ID))
{
UpdateBeatmapSet(beatmapSet.Detach());
}
}
}
private IRealmCollection<BeatmapSetInfo> getBeatmapSets(Realm realm) => realm.All<BeatmapSetInfo>().Where(s => !s.DeletePending && !s.Protected).AsRealmCollection();
public void RemoveBeatmapSet(BeatmapSetInfo beatmapSet) => Schedule(() =>
{
var existingSet = beatmapSets.FirstOrDefault(b => b.BeatmapSet.Equals(beatmapSet));
public void RemoveBeatmapSet(BeatmapSetInfo beatmapSet) =>
removeBeatmapSet(beatmapSet.ID);
if (existingSet == null)
private void removeBeatmapSet(Guid beatmapSetID) => Schedule(() =>
{
if (!root.BeatmapSetsByID.TryGetValue(beatmapSetID, out var existingSet))
return;
root.RemoveChild(existingSet);
@ -281,35 +292,32 @@ namespace osu.Game.Screens.Select
{
Guid? previouslySelectedID = null;
CarouselBeatmapSet existingSet = beatmapSets.FirstOrDefault(b => b.BeatmapSet.Equals(beatmapSet));
// If the selected beatmap is about to be removed, store its ID so it can be re-selected if required
if (existingSet?.State?.Value == CarouselItemState.Selected)
if (selectedBeatmapSet?.BeatmapSet.ID == beatmapSet.ID)
previouslySelectedID = selectedBeatmap?.BeatmapInfo.ID;
var newSet = createCarouselSet(beatmapSet);
if (existingSet != null)
root.RemoveChild(existingSet);
root.RemoveChild(beatmapSet.ID);
if (newSet == null)
if (newSet != null)
{
itemsCache.Invalidate();
return;
root.AddChild(newSet);
// check if we can/need to maintain our current selection.
if (previouslySelectedID != null)
select((CarouselItem)newSet.Beatmaps.FirstOrDefault(b => b.BeatmapInfo.ID == previouslySelectedID) ?? newSet);
}
root.AddChild(newSet);
// only reset scroll position if already near the scroll target.
// without this, during a large beatmap import it is impossible to navigate the carousel.
applyActiveCriteria(false, alwaysResetScrollPosition: false);
// check if we can/need to maintain our current selection.
if (previouslySelectedID != null)
select((CarouselItem)newSet.Beatmaps.FirstOrDefault(b => b.BeatmapInfo.ID == previouslySelectedID) ?? newSet);
itemsCache.Invalidate();
Schedule(() => BeatmapSetsChanged?.Invoke());
Schedule(() =>
{
if (!Scroll.UserScrolling)
ScrollToSelected(true);
BeatmapSetsChanged?.Invoke();
});
});
/// <summary>
@ -711,8 +719,6 @@ namespace osu.Game.Screens.Select
private CarouselBeatmapSet createCarouselSet(BeatmapSetInfo beatmapSet)
{
beatmapSet = beatmapSet.Detach();
// This can be moved to the realm query if required using:
// .Filter("DeletePending == false && Protected == false && ANY Beatmaps.Hidden == false")
//
@ -913,6 +919,8 @@ namespace osu.Game.Screens.Select
{
private readonly BeatmapCarousel carousel;
public readonly Dictionary<Guid, CarouselBeatmapSet> BeatmapSetsByID = new Dictionary<Guid, CarouselBeatmapSet>();
public CarouselRoot(BeatmapCarousel carousel)
{
// root should always remain selected. if not, PerformSelection will not be called.
@ -922,6 +930,28 @@ namespace osu.Game.Screens.Select
this.carousel = carousel;
}
public override void AddChild(CarouselItem i)
{
CarouselBeatmapSet set = (CarouselBeatmapSet)i;
BeatmapSetsByID.Add(set.BeatmapSet.ID, set);
base.AddChild(i);
}
public void RemoveChild(Guid beatmapSetID)
{
if (BeatmapSetsByID.TryGetValue(beatmapSetID, out var carouselBeatmapSet))
RemoveChild(carouselBeatmapSet);
}
public override void RemoveChild(CarouselItem i)
{
CarouselBeatmapSet set = (CarouselBeatmapSet)i;
BeatmapSetsByID.Remove(set.BeatmapSet.ID);
base.RemoveChild(i);
}
protected override void PerformSelection()
{
if (LastSelected == null || LastSelected.Filtered.Value)

31
osu.Game/Screens/Select/Carousel/CarouselGroup.cs
View File

@ -4,6 +4,8 @@
using System.Collections.Generic;
using System.Linq;
#nullable enable
namespace osu.Game.Screens.Select.Carousel
{
/// <summary>
@ -11,7 +13,7 @@ namespace osu.Game.Screens.Select.Carousel
/// </summary>
public class CarouselGroup : CarouselItem
{
public override DrawableCarouselItem CreateDrawableRepresentation() => null;
public override DrawableCarouselItem? CreateDrawableRepresentation() => null;
public IReadOnlyList<CarouselItem> Children => InternalChildren;
@ -23,6 +25,10 @@ namespace osu.Game.Screens.Select.Carousel
/// </summary>
private ulong currentChildID;
private Comparer<CarouselItem>? criteriaComparer;
private FilterCriteria? lastCriteria;
public virtual void RemoveChild(CarouselItem i)
{
InternalChildren.Remove(i);
@ -36,10 +42,24 @@ namespace osu.Game.Screens.Select.Carousel
{
i.State.ValueChanged += state => ChildItemStateChanged(i, state.NewValue);
i.ChildID = ++currentChildID;
InternalChildren.Add(i);
if (lastCriteria != null)
{
i.Filter(lastCriteria);
int index = InternalChildren.BinarySearch(i, criteriaComparer);
if (index < 0) index = ~index; // BinarySearch hacks multiple return values with 2's complement.
InternalChildren.Insert(index, i);
}
else
{
// criteria may be null for initial population. the filtering will be applied post-add.
InternalChildren.Add(i);
}
}
public CarouselGroup(List<CarouselItem> items = null)
public CarouselGroup(List<CarouselItem>? items = null)
{
if (items != null) InternalChildren = items;
@ -67,9 +87,12 @@ namespace osu.Game.Screens.Select.Carousel
base.Filter(criteria);
InternalChildren.ForEach(c => c.Filter(criteria));
// IEnumerable<T>.OrderBy() is used instead of List<T>.Sort() to ensure sorting stability
var criteriaComparer = Comparer<CarouselItem>.Create((x, y) => x.CompareTo(criteria, y));
criteriaComparer = Comparer<CarouselItem>.Create((x, y) => x.CompareTo(criteria, y));
InternalChildren = InternalChildren.OrderBy(c => c, criteriaComparer).ToList();
lastCriteria = criteria;
}
protected virtual void ChildItemStateChanged(CarouselItem item, CarouselItemState value)

11
osu.Game/Screens/Select/Carousel/CarouselGroupEagerSelect.cs
View File

@ -55,10 +55,16 @@ namespace osu.Game.Screens.Select.Carousel
updateSelectedIndex();
}
private bool addingChildren;
public void AddChildren(IEnumerable<CarouselItem> items)
{
addingChildren = true;
foreach (var i in items)
base.AddChild(i);
AddChild(i);
addingChildren = false;
attemptSelection();
}
@ -66,7 +72,8 @@ namespace osu.Game.Screens.Select.Carousel
public override void AddChild(CarouselItem i)
{
base.AddChild(i);
attemptSelection();
if (!addingChildren)
attemptSelection();
}
protected override void ChildItemStateChanged(CarouselItem item, CarouselItemState value)

6
osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboard.cs
View File

@ -147,7 +147,7 @@ namespace osu.Game.Screens.Select.Leaderboards
if (Scope == BeatmapLeaderboardScope.Local)
{
using (var realm = realmFactory.CreateContext())
realmFactory.Run(realm =>
{
var scores = realm.All<ScoreInfo>()
.AsEnumerable()
@ -171,9 +171,9 @@ namespace osu.Game.Screens.Select.Leaderboards
scoreManager.OrderByTotalScoreAsync(scores.ToArray(), cancellationToken)
.ContinueWith(ordered => scoresCallback?.Invoke(ordered.GetResultSafely()), TaskContinuationOptions.OnlyOnRanToCompletion);
});
return null;
}
return null;
}
if (api?.IsLoggedIn != true)

28
osu.Game/Skinning/SkinManager.cs
View File

@ -87,17 +87,14 @@ namespace osu.Game.Skinning
};
// Ensure the default entries are present.
using (var context = contextFactory.CreateContext())
using (var transaction = context.BeginWrite())
contextFactory.Write(realm =>
{
foreach (var skin in defaultSkins)
{
if (context.Find<SkinInfo>(skin.SkinInfo.ID) == null)
context.Add(skin.SkinInfo.Value);
if (realm.Find<SkinInfo>(skin.SkinInfo.ID) == null)
realm.Add(skin.SkinInfo.Value);
}
transaction.Commit();
}
});
CurrentSkinInfo.ValueChanged += skin => CurrentSkin.Value = skin.NewValue.PerformRead(GetSkin);
@ -113,10 +110,10 @@ namespace osu.Game.Skinning
public void SelectRandomSkin()
{
using (var context = contextFactory.CreateContext())
contextFactory.Run(realm =>
{
// choose from only user skins, removing the current selection to ensure a new one is chosen.
var randomChoices = context.All<SkinInfo>().Where(s => !s.DeletePending && s.ID != CurrentSkinInfo.Value.ID).ToArray();
var randomChoices = realm.All<SkinInfo>().Where(s => !s.DeletePending && s.ID != CurrentSkinInfo.Value.ID).ToArray();
if (randomChoices.Length == 0)
{
@ -127,7 +124,7 @@ namespace osu.Game.Skinning
var chosen = randomChoices.ElementAt(RNG.Next(0, randomChoices.Length));
CurrentSkinInfo.Value = chosen.ToLive(contextFactory);
}
});
}
/// <summary>
@ -182,8 +179,7 @@ namespace osu.Game.Skinning
/// <returns>The first result for the provided query, or null if no results were found.</returns>
public ILive<SkinInfo> Query(Expression<Func<SkinInfo, bool>> query)
{
using (var context = contextFactory.CreateContext())
return context.All<SkinInfo>().FirstOrDefault(query)?.ToLive(contextFactory);
return contextFactory.Run(realm => realm.All<SkinInfo>().FirstOrDefault(query)?.ToLive(contextFactory));
}
public event Action SourceChanged;
@ -293,10 +289,10 @@ namespace osu.Game.Skinning
public void Delete([CanBeNull] Expression<Func<SkinInfo, bool>> filter = null, bool silent = false)
{
using (var context = contextFactory.CreateContext())
contextFactory.Run(realm =>
{
var items = context.All<SkinInfo>()
.Where(s => !s.Protected && !s.DeletePending);
var items = realm.All<SkinInfo>()
.Where(s => !s.Protected && !s.DeletePending);
if (filter != null)
items = items.Where(filter);
@ -307,7 +303,7 @@ namespace osu.Game.Skinning
scheduler.Add(() => CurrentSkinInfo.Value = Skinning.DefaultSkin.CreateInfo().ToLiveUnmanaged());
skinModelManager.Delete(items.ToList(), silent);
}
});
}
#endregion

4
osu.Game/Skinning/SkinModelManager.cs
View File

@ -205,7 +205,7 @@ namespace osu.Game.Skinning
private void populateMissingHashes()
{
using (var realm = ContextFactory.CreateContext())
ContextFactory.Run(realm =>
{
var skinsWithoutHashes = realm.All<SkinInfo>().Where(i => !i.Protected && string.IsNullOrEmpty(i.Hash)).ToArray();
@ -221,7 +221,7 @@ namespace osu.Game.Skinning
Logger.Error(e, $"Existing skin {skin} has been deleted during hash recomputation due to being invalid");
}
}
}
});
}
private Skin createInstance(SkinInfo item) => item.CreateInstance(skinResources);

3
osu.Game/Stores/BeatmapImporter.cs
View File

@ -165,8 +165,7 @@ namespace osu.Game.Stores
public override bool IsAvailableLocally(BeatmapSetInfo model)
{
using (var context = ContextFactory.CreateContext())
return context.All<BeatmapInfo>().Any(b => b.OnlineID == model.OnlineID);
return ContextFactory.Run(realm => realm.All<BeatmapInfo>().Any(b => b.OnlineID == model.OnlineID));
}
public override string HumanisedModelName => "beatmap";

4
osu.Game/Stores/RealmArchiveModelImporter.cs
View File

@ -320,7 +320,7 @@ namespace osu.Game.Stores
/// <param name="cancellationToken">An optional cancellation token.</param>
public virtual Task<ILive<TModel>?> Import(TModel item, ArchiveReader? archive = null, bool lowPriority = false, CancellationToken cancellationToken = default)
{
using (var realm = ContextFactory.CreateContext())
return ContextFactory.Run(realm =>
{
cancellationToken.ThrowIfCancellationRequested();
@ -414,7 +414,7 @@ namespace osu.Game.Stores
}
return Task.FromResult((ILive<TModel>?)item.ToLive(ContextFactory));
}
});
}
private string computeHashFast(ArchiveReader reader)

8
osu.Game/Stores/RealmArchiveModelManager.cs
View File

@ -165,7 +165,7 @@ namespace osu.Game.Stores
public bool Delete(TModel item)
{
using (var realm = ContextFactory.CreateContext())
return ContextFactory.Run(realm =>
{
if (!item.IsManaged)
item = realm.Find<TModel>(item.ID);
@ -175,12 +175,12 @@ namespace osu.Game.Stores
realm.Write(r => item.DeletePending = true);
return true;
}
});
}
public void Undelete(TModel item)
{
using (var realm = ContextFactory.CreateContext())
ContextFactory.Run(realm =>
{
if (!item.IsManaged)
item = realm.Find<TModel>(item.ID);
@ -189,7 +189,7 @@ namespace osu.Game.Stores
return;
realm.Write(r => item.DeletePending = false);
}
});
}
public abstract bool IsAvailableLocally(TModel model);

7
osu.Game/Stores/RealmFileStore.cs
View File

@ -92,8 +92,7 @@ namespace osu.Game.Stores
int removedFiles = 0;
// can potentially be run asynchronously, although we will need to consider operation order for disk deletion vs realm removal.
using (var realm = realmFactory.CreateContext())
using (var transaction = realm.BeginWrite())
realmFactory.Write(realm =>
{
// TODO: consider using a realm native query to avoid iterating all files (https://github.com/realm/realm-dotnet/issues/2659#issuecomment-927823707)
var files = realm.All<RealmFile>().ToList();
@ -116,9 +115,7 @@ namespace osu.Game.Stores
Logger.Error(e, $@"Could not delete databased file {file.Hash}");
}
}
transaction.Commit();
}
});
Logger.Log($@"Finished realm file store cleanup ({removedFiles} of {totalFiles} deleted)");
}