1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-16 05:02:56 +08:00
osu-lazer/osu.Game/Rulesets/RulesetStore.cs

234 lines
9.5 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;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using osu.Framework;
using osu.Framework.Extensions.ObjectExtensions;
using osu.Framework.Logging;
using osu.Framework.Platform;
2018-04-13 17:19:50 +08:00
using osu.Game.Database;
namespace osu.Game.Rulesets
{
public class RulesetStore : DatabaseBackedStore, IDisposable
2018-04-13 17:19:50 +08:00
{
private const string ruleset_library_prefix = "osu.Game.Rulesets";
2018-04-13 17:19:50 +08:00
private readonly Dictionary<Assembly, Type> loadedAssemblies = new Dictionary<Assembly, Type>();
2018-04-13 17:19:50 +08:00
private readonly Storage rulesetStorage;
public RulesetStore(IDatabaseContextFactory factory, Storage storage = null)
: base(factory)
{
rulesetStorage = storage?.GetStorageForDirectory("rulesets");
2019-07-03 17:36:04 +08:00
// On android in release configuration assemblies are loaded from the apk directly into memory.
2019-07-03 17:41:01 +08:00
// We cannot read assemblies from cwd, so should check loaded assemblies instead.
2019-07-03 17:42:10 +08:00
loadFromAppDomain();
loadFromDisk();
2020-04-19 22:29:32 +08:00
// the event handler contains code for resolving dependency on the game assembly for rulesets located outside the base game directory.
// It needs to be attached to the assembly lookup event before the actual call to loadUserRulesets() else rulesets located out of the base game directory will fail
// to load as unable to locate the game core assembly.
2020-04-07 18:20:54 +08:00
AppDomain.CurrentDomain.AssemblyResolve += resolveRulesetDependencyAssembly;
loadUserRulesets();
addMissingRulesets();
2018-04-13 17:19:50 +08:00
}
/// <summary>
/// Retrieve a ruleset using a known ID.
/// </summary>
/// <param name="id">The ruleset's internal ID.</param>
/// <returns>A ruleset, if available, else null.</returns>
public RulesetInfo GetRuleset(int id) => AvailableRulesets.FirstOrDefault(r => r.ID == id);
/// <summary>
/// Retrieve a ruleset using a known short name.
/// </summary>
/// <param name="shortName">The ruleset's short name.</param>
/// <returns>A ruleset, if available, else null.</returns>
public RulesetInfo GetRuleset(string shortName) => AvailableRulesets.FirstOrDefault(r => r.ShortName == shortName);
/// <summary>
/// All available rulesets.
/// </summary>
public IEnumerable<RulesetInfo> AvailableRulesets { get; private set; }
2018-04-13 17:19:50 +08:00
private Assembly resolveRulesetDependencyAssembly(object sender, ResolveEventArgs args)
{
var asm = new AssemblyName(args.Name);
2020-04-07 18:20:54 +08:00
// the requesting assembly may be located out of the executable's base directory, thus requiring manual resolving of its dependencies.
// this attempts resolving the ruleset dependencies on game core and framework assemblies by returning assemblies with the same assembly name
// already loaded in the AppDomain.
var domainAssembly = AppDomain.CurrentDomain.GetAssemblies()
// Given name is always going to be equally-or-more qualified than the assembly name.
.Where(a => args.Name.Contains(a.GetName().Name, StringComparison.Ordinal))
// Pick the greatest assembly version.
2020-07-31 15:21:47 +08:00
.OrderByDescending(a => a.GetName().Version)
.FirstOrDefault();
if (domainAssembly != null)
return domainAssembly;
return loadedAssemblies.Keys.FirstOrDefault(a => a.FullName == asm.FullName);
}
2018-04-13 17:19:50 +08:00
private void addMissingRulesets()
2018-04-13 17:19:50 +08:00
{
using (var usage = ContextFactory.GetForWrite())
{
var context = usage.Context;
var instances = loadedAssemblies.Values.Select(r => (Ruleset)Activator.CreateInstance(r)).ToList();
2018-04-13 17:19:50 +08:00
2020-05-05 09:31:11 +08:00
// add all legacy rulesets first to ensure they have exclusive choice of primary key.
2019-12-24 12:48:27 +08:00
foreach (var r in instances.Where(r => r is ILegacyRuleset))
2018-04-13 17:19:50 +08:00
{
if (context.RulesetInfo.SingleOrDefault(dbRuleset => dbRuleset.ID == r.RulesetInfo.ID) == null)
2018-04-13 17:19:50 +08:00
context.RulesetInfo.Add(r.RulesetInfo);
}
context.SaveChanges();
2020-10-16 22:40:44 +08:00
var existingRulesets = context.RulesetInfo.ToList();
// add any other rulesets which have assemblies present but are not yet in the database.
2019-12-24 12:48:27 +08:00
foreach (var r in instances.Where(r => !(r is ILegacyRuleset)))
2019-11-11 19:53:22 +08:00
{
if (existingRulesets.FirstOrDefault(ri => ri.InstantiationInfo.Equals(r.RulesetInfo.InstantiationInfo, StringComparison.Ordinal)) == null)
{
var existingSameShortName = existingRulesets.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
context.RulesetInfo.Add(r.RulesetInfo);
}
2019-11-11 19:53:22 +08:00
}
2018-04-13 17:19:50 +08:00
context.SaveChanges();
2020-05-05 09:31:11 +08:00
// perform a consistency check
2018-04-13 17:19:50 +08:00
foreach (var r in context.RulesetInfo)
{
try
{
var instanceInfo = ((Ruleset)Activator.CreateInstance(Type.GetType(r.InstantiationInfo).AsNonNull())).RulesetInfo;
2018-04-13 17:19:50 +08:00
r.Name = instanceInfo.Name;
r.ShortName = instanceInfo.ShortName;
r.InstantiationInfo = instanceInfo.InstantiationInfo;
2018-04-13 17:19:50 +08:00
r.Available = true;
}
catch
{
r.Available = false;
}
}
context.SaveChanges();
AvailableRulesets = context.RulesetInfo.Where(r => r.Available).ToList();
}
}
private void loadFromAppDomain()
{
2019-07-02 23:25:12 +08:00
foreach (var ruleset in AppDomain.CurrentDomain.GetAssemblies())
{
string rulesetName = ruleset.GetName().Name;
if (!rulesetName.StartsWith(ruleset_library_prefix, StringComparison.InvariantCultureIgnoreCase) || ruleset.GetName().Name.Contains("Tests"))
continue;
addRuleset(ruleset);
2019-07-02 23:25:12 +08:00
}
}
private void loadUserRulesets()
{
if (rulesetStorage == null) return;
var rulesets = rulesetStorage.GetFiles(".", $"{ruleset_library_prefix}.*.dll");
2020-04-07 18:20:54 +08:00
foreach (var ruleset in rulesets.Where(f => !f.Contains("Tests")))
loadRulesetFromFile(rulesetStorage.GetFullPath(ruleset));
}
private void loadFromDisk()
2019-07-03 17:42:10 +08:00
{
try
{
var files = Directory.GetFiles(RuntimeInfo.StartupDirectory, $"{ruleset_library_prefix}.*.dll");
2019-07-03 17:42:10 +08:00
foreach (string file in files.Where(f => !Path.GetFileName(f).Contains("Tests")))
loadRulesetFromFile(file);
}
2019-10-01 14:41:01 +08:00
catch (Exception e)
2019-07-03 17:42:10 +08:00
{
Logger.Error(e, $"Could not load rulesets from directory {RuntimeInfo.StartupDirectory}");
2019-07-03 17:42:10 +08:00
}
}
private void loadRulesetFromFile(string file)
2018-04-13 17:19:50 +08:00
{
var filename = Path.GetFileNameWithoutExtension(file);
if (loadedAssemblies.Values.Any(t => Path.GetFileNameWithoutExtension(t.Assembly.Location) == filename))
2018-04-13 17:19:50 +08:00
return;
try
{
addRuleset(Assembly.LoadFrom(file));
2018-04-13 17:19:50 +08:00
}
catch (Exception e)
2018-04-13 17:19:50 +08:00
{
Logger.Error(e, $"Failed to load ruleset {filename}");
2018-04-13 17:19:50 +08:00
}
}
private void addRuleset(Assembly assembly)
{
if (loadedAssemblies.ContainsKey(assembly))
return;
// the same assembly may be loaded twice in the same AppDomain (currently a thing in certain Rider versions https://youtrack.jetbrains.com/issue/RIDER-48799).
// as a failsafe, also compare by FullName.
if (loadedAssemblies.Any(a => a.Key.FullName == assembly.FullName))
return;
try
{
loadedAssemblies[assembly] = assembly.GetTypes().First(t => t.IsPublic && t.IsSubclassOf(typeof(Ruleset)));
}
catch (Exception e)
{
Logger.Error(e, $"Failed to add ruleset {assembly}");
}
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
AppDomain.CurrentDomain.AssemblyResolve -= resolveRulesetDependencyAssembly;
}
2018-04-13 17:19:50 +08:00
}
}