mirror of
https://github.com/ppy/osu.git
synced 2024-12-14 08:43:01 +08:00
197 lines
8.7 KiB
C#
197 lines
8.7 KiB
C#
// 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;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using osu.Framework.Extensions.ObjectExtensions;
|
|
using osu.Framework.Logging;
|
|
using osu.Framework.Platform;
|
|
using osu.Game.Beatmaps;
|
|
using osu.Game.Database;
|
|
|
|
namespace osu.Game.Rulesets
|
|
{
|
|
public class RealmRulesetStore : RulesetStore
|
|
{
|
|
private readonly RealmAccess realmAccess;
|
|
public override IEnumerable<RulesetInfo> AvailableRulesets => availableRulesets;
|
|
|
|
private readonly List<RulesetInfo> availableRulesets = new List<RulesetInfo>();
|
|
|
|
public RealmRulesetStore(RealmAccess realmAccess, Storage? storage = null)
|
|
: base(storage)
|
|
{
|
|
this.realmAccess = realmAccess;
|
|
prepareDetachedRulesets();
|
|
informUserAboutBrokenRulesets();
|
|
}
|
|
|
|
private void prepareDetachedRulesets()
|
|
{
|
|
realmAccess.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))
|
|
{
|
|
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));
|
|
}
|
|
|
|
// 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)
|
|
{
|
|
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));
|
|
}
|
|
}
|
|
|
|
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
|
|
{
|
|
var resolvedType = Type.GetType(r.InstantiationInfo);
|
|
|
|
if (resolvedType == null)
|
|
{
|
|
// ruleset DLL was probably deleted.
|
|
r.Available = false;
|
|
continue;
|
|
}
|
|
|
|
var instance = (Activator.CreateInstance(resolvedType) as Ruleset);
|
|
var instanceInfo = instance?.RulesetInfo
|
|
?? throw new RulesetLoadException(@"Instantiation failure");
|
|
|
|
if (!checkRulesetUpToDate(instance))
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(instance.RulesetAPIVersionSupported),
|
|
$"Ruleset API version is too old (was {instance.RulesetAPIVersionSupported}, expected {Ruleset.CURRENT_RULESET_API_VERSION})");
|
|
}
|
|
|
|
// If a ruleset isn't up-to-date with the API, it could cause a crash at an arbitrary point of execution.
|
|
// To eagerly handle cases of missing implementations, enumerate all types here and mark as non-available on throw.
|
|
resolvedType.Assembly.GetTypes();
|
|
|
|
r.Name = instanceInfo.Name;
|
|
r.ShortName = instanceInfo.ShortName;
|
|
r.InstantiationInfo = instanceInfo.InstantiationInfo;
|
|
r.Available = true;
|
|
|
|
testRulesetCompatibility(r);
|
|
|
|
detachedRulesets.Add(r.Clone());
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
r.Available = false;
|
|
LogFailedLoad(r.Name, ex);
|
|
}
|
|
}
|
|
|
|
availableRulesets.AddRange(detachedRulesets.Order());
|
|
});
|
|
}
|
|
|
|
private bool checkRulesetUpToDate(Ruleset instance)
|
|
{
|
|
switch (instance.RulesetAPIVersionSupported)
|
|
{
|
|
// The default `virtual` implementation leaves the version string empty.
|
|
// Consider rulesets which haven't override the version as up-to-date for now.
|
|
// At some point (once ruleset devs add versioning), we'll probably want to disallow this for deployed builds.
|
|
case @"":
|
|
// Ruleset is up-to-date, all good.
|
|
case Ruleset.CURRENT_RULESET_API_VERSION:
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private void testRulesetCompatibility(RulesetInfo rulesetInfo)
|
|
{
|
|
// do various operations to ensure that we are in a good state.
|
|
// if we can avoid loading the ruleset at this point (rather than erroring later in runtime) then that is preferred.
|
|
var instance = rulesetInfo.CreateInstance();
|
|
|
|
instance.CreateAllMods();
|
|
instance.CreateIcon();
|
|
instance.CreateResourceStore();
|
|
|
|
var beatmap = new Beatmap();
|
|
var converter = instance.CreateBeatmapConverter(beatmap);
|
|
|
|
instance.CreateBeatmapProcessor(converter.Convert());
|
|
}
|
|
|
|
private void informUserAboutBrokenRulesets()
|
|
{
|
|
if (RulesetStorage == null)
|
|
return;
|
|
|
|
foreach (string brokenRulesetDll in RulesetStorage.GetFiles(@".", @"*.dll.broken"))
|
|
{
|
|
Logger.Log($"Ruleset '{Path.GetFileNameWithoutExtension(brokenRulesetDll)}' has been disabled due to causing a crash.\n\n"
|
|
+ "Please update the ruleset or report the issue to the developers of the ruleset if no updates are available.", level: LogLevel.Important);
|
|
}
|
|
}
|
|
|
|
internal void TryDisableCustomRulesetsCausing(Exception exception)
|
|
{
|
|
try
|
|
{
|
|
var stackTrace = new StackTrace(exception);
|
|
|
|
foreach (var frame in stackTrace.GetFrames())
|
|
{
|
|
var declaringAssembly = frame.GetMethod()?.DeclaringType?.Assembly;
|
|
if (declaringAssembly == null)
|
|
continue;
|
|
|
|
if (UserRulesetAssemblies.Contains(declaringAssembly))
|
|
{
|
|
string sourceLocation = declaringAssembly.Location;
|
|
string destinationLocation = Path.ChangeExtension(sourceLocation, @".dll.broken");
|
|
|
|
if (File.Exists(sourceLocation))
|
|
{
|
|
Logger.Log($"Unhandled exception traced back to custom ruleset {Path.GetFileNameWithoutExtension(sourceLocation)}. Marking as broken.");
|
|
File.Move(sourceLocation, destinationLocation);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.Log($"Attempt to trace back crash to custom ruleset failed: {ex}");
|
|
}
|
|
}
|
|
}
|
|
}
|