You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

534 lines
20 KiB

using IPA.Utilities;
using IPA.Loader;
using Ionic.Zip;
using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.Networking;
using SemVer;
using Logger = IPA.Logging.Logger;
using Version = SemVer.Version;
using IPA.Updating.Backup;
using System.Runtime.Serialization;
using System.Reflection;
using static IPA.Loader.PluginManager;
namespace IPA.Updating.ModsaberML
{
class Updater : MonoBehaviour
{
public static Updater instance;
public void Awake()
{
try
{
if (instance != null)
Destroy(this);
else
{
instance = this;
CheckForUpdates();
}
}
catch (Exception e)
{
Logger.updater.Error(e);
}
}
private void CheckForUpdates()
{
StartCoroutine(CheckForUpdatesCoroutine());
}
private class DependencyObject
{
public string Name { get; set; }
public Version Version { get; set; } = null;
public Version ResolvedVersion { get; set; } = null;
public Range Requirement { get; set; } = null;
public bool Resolved { get; set; } = false;
public bool Has { get; set; } = false;
public HashSet<string> Consumers { get; set; } = new HashSet<string>();
public bool MetaRequestFailed { get; set; } = false;
public BSPluginMeta LocalPluginMeta { get; set; } = null;
public override string ToString()
{
return $"{Name}@{Version}{(Resolved ? $" -> {ResolvedVersion}" : "")} - ({Requirement}) {(Has ? $" Already have" : "")}";
}
}
private Dictionary<string, ApiEndpoint.Mod> requestCache = new Dictionary<string, ApiEndpoint.Mod>();
private IEnumerator DownloadModInfo(string name, string ver, Ref<ApiEndpoint.Mod> result)
{
var uri = ApiEndpoint.ApiBase + string.Format(ApiEndpoint.GetApprovedEndpoint, name, ver);
if (requestCache.TryGetValue(uri, out ApiEndpoint.Mod value))
{
result.Value = value;
yield break;
}
else
{
using (var request = UnityWebRequest.Get(uri))
{
yield return request.SendWebRequest();
if (request.isNetworkError)
{
result.Error = new NetworkException($"Network error while trying to download: {request.error}");
yield break;
}
if (request.isHttpError)
{
if (request.responseCode == 404)
{
result.Error = new NetworkException("Not found");
yield break;
}
result.Error = new NetworkException($"Server returned error {request.error} while getting data");
yield break;
}
try
{
result.Value = JsonConvert.DeserializeObject<ApiEndpoint.Mod>(request.downloadHandler.text);
requestCache[uri] = result.Value;
}
catch (Exception e)
{
result.Error = new Exception("Error decoding response", e);
yield break;
}
}
}
}
private IEnumerator CheckForUpdatesCoroutine()
{
var depList = new Ref<List<DependencyObject>>(new List<DependencyObject>());
foreach (var plugin in BSMetas)
{ // initialize with data to resolve (1.1)
if (plugin.ModsaberInfo != null)
{ // updatable
var msinfo = plugin.ModsaberInfo;
depList.Value.Add(new DependencyObject {
Name = msinfo.InternalName,
Version = new Version(msinfo.CurrentVersion),
Requirement = new Range($">={msinfo.CurrentVersion}"),
LocalPluginMeta = plugin
});
}
}
foreach (var dep in depList.Value)
Logger.updater.Debug($"Phantom Dependency: {dep.ToString()}");
yield return DependencyResolveFirstPass(depList);
foreach (var dep in depList.Value)
Logger.updater.Debug($"Dependency: {dep.ToString()}");
yield return DependencyResolveSecondPass(depList);
foreach (var dep in depList.Value)
Logger.updater.Debug($"Dependency: {dep.ToString()}");
DependendyResolveFinalPass(depList);
}
private IEnumerator DependencyResolveFirstPass(Ref<List<DependencyObject>> list)
{
for (int i = 0; i < list.Value.Count; i++)
{ // Grab dependencies (1.2)
var dep = list.Value[i];
var mod = new Ref<ApiEndpoint.Mod>(null);
#region TEMPORARY get latest // SHOULD BE GREATEST OF VERSION
yield return DownloadModInfo(dep.Name, "", mod);
#endregion
try { mod.Verify(); }
catch (Exception e)
{
Logger.updater.Error($"Error getting info for {dep.Name}");
Logger.updater.Error(e);
dep.MetaRequestFailed = true;
continue;
}
list.Value.AddRange(mod.Value.Dependencies.Select(d => new DependencyObject { Name = d.Name, Requirement = d.VersionRange, Consumers = new HashSet<string>() { dep.Name } }));
}
var depNames = new HashSet<string>();
var final = new List<DependencyObject>();
foreach (var dep in list.Value)
{ // agregate ranges and the like (1.3)
if (!depNames.Contains(dep.Name))
{ // should add it
depNames.Add(dep.Name);
final.Add(dep);
}
else
{
var toMod = final.Where(d => d.Name == dep.Name).First();
toMod.Requirement = toMod.Requirement.Intersect(dep.Requirement);
foreach (var consume in dep.Consumers)
toMod.Consumers.Add(consume);
}
}
list.Value = final;
}
private IEnumerator DependencyResolveSecondPass(Ref<List<DependencyObject>> list)
{
IEnumerator GetGameVersionMap(string modname, Ref<Dictionary<Version,Version>> map)
{ // gets map of mod version -> game version (2.0)
map.Value = new Dictionary<Version, Version>();
var mod = new Ref<ApiEndpoint.Mod>(null);
yield return DownloadModInfo(modname, "", mod);
try { mod.Verify(); }
catch (Exception)
{
map.Value = null;
map.Error = new Exception($"Error getting info for {modname}", mod.Error);
yield break;
}
map.Value.Add(mod.Value.Version, mod.Value.GameVersion);
foreach (var ver in mod.Value.OldVersions)
{
yield return DownloadModInfo(modname, ver.ToString(), mod);
try { mod.Verify(); }
catch (Exception e)
{
Logger.updater.Error($"Error getting info for {modname}v{ver}");
Logger.updater.Error(e);
continue;
}
map.Value.Add(mod.Value.Version, mod.Value.GameVersion);
}
}
foreach(var dep in list.Value)
{
dep.Has = dep.Version != null;// dep.Version is only not null if its already installed
if (dep.MetaRequestFailed)
{
Logger.updater.Warn($"{dep.Name} info request failed, not trying again");
continue;
}
var dict = new Ref<Dictionary<Version, Version>>(null);
yield return GetGameVersionMap(dep.Name, dict);
try { dict.Verify(); }
catch (Exception e)
{
Logger.updater.Error($"Error getting map for {dep.Name}");
Logger.updater.Error(e);
dep.MetaRequestFailed = true;
continue;
}
var ver = dep.Requirement.MaxSatisfying(dict.Value.Where(kvp => kvp.Value == BeatSaber.GameVersion).Select(kvp => kvp.Key)); // (2.1)
if (dep.Resolved = ver != null) dep.ResolvedVersion = ver; // (2.2)
dep.Has = dep.Version == dep.ResolvedVersion && dep.Resolved; // dep.Version is only not null if its already installed
}
}
private void DependendyResolveFinalPass(Ref<List<DependencyObject>> list)
{ // also starts download of mods
var toDl = new List<DependencyObject>();
foreach (var dep in list.Value)
{ // figure out which ones need to be downloaded (3.1)
if (dep.Resolved)
{
Logger.updater.Debug($"Resolved: {dep.ToString()}");
if (!dep.Has)
{
Logger.updater.Debug($"To Download: {dep.ToString()}");
toDl.Add(dep);
}
}
else if (!dep.Has)
{
Logger.updater.Warn($"Could not resolve dependency {dep}");
}
}
Logger.updater.Debug($"To Download {string.Join(", ", toDl.Select(d => $"{d.Name}@{d.ResolvedVersion}"))}");
string tempDirectory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + Path.GetRandomFileName());
Directory.CreateDirectory(tempDirectory);
Logger.updater.Debug($"Temp directory: {tempDirectory}");
foreach (var item in toDl)
StartCoroutine(UpdateModCoroutine(item, tempDirectory));
}
private IEnumerator UpdateModCoroutine(DependencyObject item, string tempDirectory)
{ // (3.2)
Logger.updater.Debug($"Release: {BeatSaber.ReleaseType}");
var mod = new Ref<ApiEndpoint.Mod>(null);
yield return DownloadModInfo(item.Name, item.ResolvedVersion.ToString(), mod);
try { mod.Verify(); }
catch (Exception e)
{
Logger.updater.Error($"Error occurred while trying to get information for {item}");
Logger.updater.Error(e);
yield break;
}
ApiEndpoint.Mod.PlatformFile platformFile;
if (BeatSaber.ReleaseType == BeatSaber.Release.Steam || mod.Value.Files.Oculus == null)
platformFile = mod.Value.Files.Steam;
else
platformFile = mod.Value.Files.Oculus;
string url = platformFile.DownloadPath;
Logger.updater.Debug($"URL = {url}");
const int MaxTries = 3;
int maxTries = MaxTries;
while (maxTries > 0)
{
if (maxTries-- != MaxTries)
Logger.updater.Debug($"Re-trying download...");
using (var stream = new MemoryStream())
using (var request = UnityWebRequest.Get(url))
using (var taskTokenSource = new CancellationTokenSource())
{
var dlh = new StreamDownloadHandler(stream);
request.downloadHandler = dlh;
Logger.updater.Debug("Sending request");
//Logger.updater.Debug(request?.downloadHandler?.ToString() ?? "DLH==NULL");
yield return request.SendWebRequest();
Logger.updater.Debug("Download finished");
if (request.isNetworkError)
{
Logger.updater.Error("Network error while trying to update mod");
Logger.updater.Error(request.error);
taskTokenSource.Cancel();
continue;
}
if (request.isHttpError)
{
Logger.updater.Error($"Server returned an error code while trying to update mod");
Logger.updater.Error(request.error);
taskTokenSource.Cancel();
continue;
}
stream.Seek(0, SeekOrigin.Begin); // reset to beginning
var downloadTask = Task.Run(() =>
{ // use slightly more multithreaded approach than coroutines
ExtractPluginAsync(stream, item, platformFile, tempDirectory);
}, taskTokenSource.Token);
while (!(downloadTask.IsCompleted || downloadTask.IsCanceled || downloadTask.IsFaulted))
yield return null; // pause coroutine until task is done
if (downloadTask.IsFaulted)
{
Logger.updater.Error($"Error downloading mod {item.Name}");
Logger.updater.Error(downloadTask.Exception);
continue;
}
break;
}
}
if (maxTries == 0)
Logger.updater.Warn($"Plugin download failed {MaxTries} times, not re-trying");
else
Logger.updater.Debug("Download complete");
}
internal class StreamDownloadHandler : DownloadHandlerScript
{
public MemoryStream Stream { get; set; }
public StreamDownloadHandler(MemoryStream stream) : base()
{
Stream = stream;
}
protected override void ReceiveContentLength(int contentLength)
{
Stream.Capacity = contentLength;
Logger.updater.Debug($"Got content length: {contentLength}");
}
protected override void CompleteContent()
{
Logger.updater.Debug("Download complete");
}
protected override bool ReceiveData(byte[] data, int dataLength)
{
if (data == null || data.Length < 1)
{
Logger.updater.Debug("CustomWebRequest :: ReceiveData - received a null/empty buffer");
return false;
}
Stream.Write(data, 0, dataLength);
return true;
}
protected override byte[] GetData() { return null; }
protected override float GetProgress()
{
return 0f;
}
public override string ToString()
{
return $"{base.ToString()} ({Stream?.ToString()})";
}
}
private void ExtractPluginAsync(MemoryStream stream, DependencyObject item, ApiEndpoint.Mod.PlatformFile fileInfo, string tempDirectory)
{ // (3.3)
Logger.updater.Debug($"Extracting ZIP file for {item.Name}");
var data = stream.GetBuffer();
SHA1 sha = new SHA1CryptoServiceProvider();
var hash = sha.ComputeHash(data);
if (!LoneFunctions.UnsafeCompare(hash, fileInfo.Hash))
throw new Exception("The hash for the file doesn't match what is defined");
var newFiles = new List<FileInfo>();
var backup = new BackupUnit(tempDirectory, $"backup-{item.Name}");
try
{
bool shouldDeleteOldFile = true;
using (var zipFile = ZipFile.Read(stream))
{
Logger.updater.Debug("Streams opened");
foreach (var entry in zipFile)
{
if (entry.IsDirectory)
{
Logger.updater.Debug($"Creating directory {entry.FileName}");
Directory.CreateDirectory(Path.Combine(Environment.CurrentDirectory, entry.FileName));
}
else
{
using (var ostream = new MemoryStream((int)entry.UncompressedSize))
{
entry.Extract(ostream);
ostream.Seek(0, SeekOrigin.Begin);
sha = new SHA1CryptoServiceProvider();
var fileHash = sha.ComputeHash(ostream);
if (!LoneFunctions.UnsafeCompare(fileHash, fileInfo.FileHashes[entry.FileName]))
throw new Exception("The hash for the file doesn't match what is defined");
ostream.Seek(0, SeekOrigin.Begin);
FileInfo targetFile = new FileInfo(Path.Combine(Environment.CurrentDirectory, entry.FileName));
Directory.CreateDirectory(targetFile.DirectoryName);
if (targetFile.FullName == item.LocalPluginMeta?.Filename)
shouldDeleteOldFile = false; // overwriting old file, no need to delete
if (targetFile.Exists)
backup.Add(targetFile);
else
newFiles.Add(targetFile);
Logger.updater.Debug($"Extracting file {targetFile.FullName}");
targetFile.Delete();
var fstream = targetFile.Create();
ostream.CopyTo(fstream);
}
}
}
}
if (item.LocalPluginMeta?.Plugin is SelfPlugin)
{ // currently updating self
Process.Start(new ProcessStartInfo
{
FileName = item.LocalPluginMeta.Filename,
Arguments = $"-nw={Process.GetCurrentProcess().Id}",
UseShellExecute = false
});
}
else if (shouldDeleteOldFile && item.LocalPluginMeta != null)
File.Delete(item.LocalPluginMeta.Filename);
}
catch (Exception)
{ // something failed; restore
foreach (var file in newFiles)
file.Delete();
backup.Restore();
backup.Delete();
throw;
}
backup.Delete();
Logger.updater.Debug("Extractor exited");
}
}
[Serializable]
internal class NetworkException : Exception
{
public NetworkException()
{
}
public NetworkException(string message) : base(message)
{
}
public NetworkException(string message, Exception innerException) : base(message, innerException)
{
}
protected NetworkException(SerializationInfo info, StreamingContext context) : base(info, context)
{
}
}
}