spt/modules
spt/modules
0
0
Fork 0
mirror of https://github.com/sp-tarkov/modules.git synced 2025-02-12 22:30:44 -05:00
Code

Revert "Revert "Improve async bundles (!123)""

Browse Source 
This reverts commit 64296e3e62e92cc1b4a77f91384e579008872d95.
This commit is contained in:
Dev 2024-05-12 23:22:37 +01:00
parent 64296e3e62
commit 336ad97bc8
3 changed files with 63 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
project/Aki.Custom/Patches/EasyAssetsPatch.cs
View File

@ -1,21 +1,19 @@
using Aki.Reflection.Patching;
using Diz.Jobs;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using Diz.Resources;
using JetBrains.Annotations;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.Build.Pipeline;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using Aki.Common.Utils;
using Aki.Custom.Models;
using Aki.Custom.Utils;
using DependencyGraph = DependencyGraph<IEasyBundle>;
using Aki.Reflection.Patching;
using Aki.Reflection.Utils;
using DependencyGraph = DependencyGraph<IEasyBundle>;
namespace Aki.Custom.Patches
{
@ -38,40 +36,33 @@ namespace Aki.Custom.Patches
protected override MethodBase GetTargetMethod()
{
return typeof(EasyAssets).GetMethods(PatchConstants.PublicDeclaredFlags).SingleCustom(IsTargetMethod);
}
private static bool IsTargetMethod(MethodInfo mi)
{
var parameters = mi.GetParameters();
return (parameters.Length == 6
&& parameters[0].Name == "bundleLock"
&& parameters[1].Name == "defaultKey"
&& parameters[4].Name == "shouldExclude");
return typeof(EasyAssets).GetMethod(nameof(EasyAssets.Create));
}
[PatchPrefix]
private static bool PatchPrefix(ref Task __result, EasyAssets __instance, [CanBeNull] IBundleLock bundleLock, string defaultKey, string rootPath,
private static bool PatchPrefix(ref Task<EasyAssets> __result, GameObject gameObject, [CanBeNull] IBundleLock bundleLock, string defaultKey, string rootPath,
string platformName, [CanBeNull] Func<string, bool> shouldExclude, [CanBeNull] Func<string, Task> bundleCheck)
{
__result = Init(__instance, bundleLock, defaultKey, rootPath, platformName, shouldExclude, bundleCheck);
var easyAsset = gameObject.AddComponent<EasyAssets>();
__result = Init(easyAsset, bundleLock, defaultKey, rootPath, platformName, shouldExclude, bundleCheck);
return false;
}
private static async Task Init(EasyAssets instance, [CanBeNull] IBundleLock bundleLock, string defaultKey, string rootPath, string platformName, [CanBeNull] Func<string, bool> shouldExclude, Func<string, Task> bundleCheck)
private static async Task<EasyAssets> Init(EasyAssets instance, [CanBeNull] IBundleLock bundleLock, string defaultKey, string rootPath, string platformName, [CanBeNull] Func<string, bool> shouldExclude, Func<string, Task> bundleCheck)
{
// platform manifest
var path = $"{rootPath.Replace("file:///", string.Empty).Replace("file://", string.Empty)}/{platformName}/";
var filepath = path + platformName;
var eftBundlesPath = $"{rootPath.Replace("file:///", string.Empty).Replace("file://", string.Empty)}/{platformName}/";
var filepath = eftBundlesPath + platformName;
var jsonfile = filepath + ".json";
var manifest = File.Exists(jsonfile)
var manifest = VFS.Exists(jsonfile)
? await GetManifestJson(jsonfile)
: await GetManifestBundle(filepath);
// lazy-initialize aki bundles
if (BundleManager.Bundles.Keys.Count == 0)
{
await BundleManager.GetBundles();
await BundleManager.DownloadManifest();
}
// create bundles array from obfuscated type
@ -85,27 +76,43 @@ namespace Aki.Custom.Patches
bundleLock = new BundleLock(int.MaxValue);
}
// create bundle of obfuscated type
var bundles = (IEasyBundle[])Array.CreateInstance(EasyBundleHelper.Type, bundleNames.Length);
for (var i = 0; i < bundleNames.Length; i++)
{
var key = bundleNames[i];
var path = eftBundlesPath;
// acquire external bundle
if (BundleManager.Bundles.TryGetValue(key, out var bundleInfo))
{
// we need base path without file extension
path = BundleManager.GetBundlePath(bundleInfo);
// only download when connected externally
if (await BundleManager.ShouldReaquire(bundleInfo))
{
await BundleManager.DownloadBundle(bundleInfo);
}
}
// create bundle of obfuscated type
bundles[i] = (IEasyBundle)Activator.CreateInstance(EasyBundleHelper.Type, new object[]
{
bundleNames[i],
key,
path,
manifest,
bundleLock,
bundleCheck
});
await JobScheduler.Yield(EJobPriority.Immediate);
}
// create dependency graph
instance.Manifest = manifest;
_bundlesField.SetValue(instance, bundles);
instance.System = new DependencyGraph(bundles, defaultKey, shouldExclude);
return instance;
}
// NOTE: used by:

8
project/Aki.Custom/Patches/EasyBundlePatch.cs
View File

@ -1,12 +1,12 @@
using System;
using Aki.Reflection.Patching;
using Diz.DependencyManager;
using UnityEngine.Build.Pipeline;
using System.IO;
using System.Linq;
using System.Reflection;
using Diz.DependencyManager;
using UnityEngine.Build.Pipeline;
using Aki.Custom.Models;
using Aki.Custom.Utils;
using Aki.Reflection.Patching;
namespace Aki.Custom.Patches
{
@ -38,7 +38,7 @@ namespace Aki.Custom.Patches
: bundle.Dependencies;
// set path to either cache (HTTP) or mod (local)
filepath = BundleManager.GetBundlePath(bundle);
filepath = BundleManager.GetBundleFilePath(bundle);
}
_ = new EasyBundleHelper(__instance)

63
project/Aki.Custom/Utils/BundleManager.cs
View File

@ -10,74 +10,51 @@ namespace Aki.Custom.Utils
{
public static class BundleManager
{
private const string CachePath = "user/cache/bundles/";
private static readonly ManualLogSource _logger;
public static readonly ConcurrentDictionary<string, BundleItem> Bundles;
public static string CachePath;
static BundleManager()
{
_logger = Logger.CreateLogSource(nameof(BundleManager));
Bundles = new ConcurrentDictionary<string, BundleItem>();
CachePath = "user/cache/bundles/";
}
public static string GetBundlePath(BundleItem bundle)
{
return RequestHandler.IsLocal
? $"{bundle.ModPath}/bundles/{bundle.FileName}"
: CachePath + bundle.FileName;
: CachePath;
}
public static async Task GetBundles()
public static string GetBundleFilePath(BundleItem bundle)
{
return GetBundlePath(bundle) + bundle.FileName;
}
public static async Task DownloadManifest()
{
// get bundles
var json = RequestHandler.GetJson("/singleplayer/bundles");
var json = await RequestHandler.GetJsonAsync("/singleplayer/bundles");
var bundles = JsonConvert.DeserializeObject<BundleItem[]>(json);
// register bundles
var toDownload = new ConcurrentBag<BundleItem>();
foreach (var bundle in bundles)
{
Bundles.TryAdd(bundle.FileName, bundle);
if (await ShouldReaquire(bundle))
{
// mark for download
toDownload.Add(bundle);
}
}
if (RequestHandler.IsLocal)
{
// loading from local mods
_logger.LogInfo("CACHE: Loading all bundles from mods on disk.");
return;
}
else
{
// download bundles
// NOTE: assumes bundle keys to be unique
foreach (var bundle in toDownload)
{
// download bundle
var filepath = GetBundlePath(bundle);
var data = await RequestHandler.GetDataAsync($"/files/bundle/{bundle.FileName}");
await VFS.WriteFileAsync(filepath, data);
}
}
}
private static async Task<bool> ShouldReaquire(BundleItem bundle)
public static async Task DownloadBundle(BundleItem bundle)
{
if (RequestHandler.IsLocal)
{
// only handle remote bundles
return false;
}
var filepath = GetBundleFilePath(bundle);
var data = await RequestHandler.GetDataAsync($"/files/bundle/{bundle.FileName}");
await VFS.WriteFileAsync(filepath, data);
}
public static async Task<bool> ShouldReaquire(BundleItem bundle)
{
// read cache
var filepath = CachePath + bundle.FileName;
var filepath = GetBundleFilePath(bundle);
if (VFS.Exists(filepath))
{
@ -88,7 +65,11 @@ namespace Aki.Custom.Utils
if (crc == bundle.Crc)
{
// file is up-to-date
_logger.LogInfo($"CACHE: Loading locally {bundle.FileName}");
var location = RequestHandler.IsLocal
? "MOD"
: "CACHE";
_logger.LogInfo($"{location}: Loading locally {bundle.FileName}");
return false;
}
else