NebulaTeam/NebulaLauncher
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- tweak: loading popup thinks

Browse Source 
* - tweak: change loading handle logic

* - tweak: beautify loading thinks

* - fix: speed thinks while downloading
This commit is contained in:
Cinkafox
2025-12-06 23:25:25 +03:00
committed by GitHub
parent d7f775e80c
commit 0c6bbaadac
39 changed files with 710 additions and 491 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
Nebula.Shared/Services/ConfigurationService.cs
View File

@@ -32,19 +32,18 @@ public class ConfigurationService
ConfigurationApi = fileService.CreateFileApi("config");
}
public void MigrateConfigs(ILoadingHandler loadingHandler)
public void MigrateConfigs(ILoadingHandlerFactory loadingHandlerFactory)
{
Task.Run(async () =>
{
var loadingHandler = loadingHandlerFactory.CreateLoadingContext();
foreach (var migration in _migrations)
{
await migration.DoMigrate(this, _serviceProvider, loadingHandler);
}
if (loadingHandler is IDisposable disposable)
{
disposable.Dispose();
}
loadingHandler.Dispose();
loadingHandlerFactory.Dispose();
});
}

152
Nebula.Shared/Services/ContentService.Download.cs
View File

@@ -1,4 +1,5 @@
using System.Buffers.Binary;
using System.Diagnostics;
using System.Globalization;
using System.Net.Http.Headers;
using System.Numerics;
@@ -34,11 +35,10 @@ public partial class ContentService
}
public async Task<HashApi> EnsureItems(ManifestReader manifestReader, Uri downloadUri,
ILoadingHandler loadingHandler,
ILoadingHandlerFactory loadingFactory,
CancellationToken cancellationToken)
{
List<RobustManifestItem> allItems = [];
List<RobustManifestItem> items = [];
while (manifestReader.TryReadItem(out var item))
{
@@ -50,40 +50,44 @@ public partial class ContentService
var hashApi = CreateHashApi(allItems);
items = allItems.Where(a=> !hashApi.Has(a)).ToList();
loadingHandler.SetLoadingMessage("Download Count:" + items.Count);
var items = allItems.Where(a=> !hashApi.Has(a)).ToList();
_logger.Log("Download Count:" + items.Count);
await Download(downloadUri, items, hashApi, loadingHandler, cancellationToken);
await Download(downloadUri, items, hashApi, loadingFactory, cancellationToken);
return hashApi;
}
public async Task<HashApi> EnsureItems(RobustManifestInfo info, ILoadingHandler loadingHandler,
public async Task<HashApi> EnsureItems(RobustManifestInfo info, ILoadingHandlerFactory loadingFactory,
CancellationToken cancellationToken)
{
_logger.Log("Getting manifest: " + info.Hash);
loadingHandler.SetLoadingMessage("Getting manifest: " + info.Hash);
var loadingHandler = loadingFactory.CreateLoadingContext(new FileLoadingFormater());
loadingHandler.SetLoadingMessage("Loading manifest");
if (ManifestFileApi.TryOpen(info.Hash, out var stream))
{
_logger.Log("Loading manifest from: " + info.Hash);
return await EnsureItems(new ManifestReader(stream), info.DownloadUri, loadingHandler, cancellationToken);
_logger.Log("Loading manifest from disk");
loadingHandler.Dispose();
return await EnsureItems(new ManifestReader(stream), info.DownloadUri, loadingFactory, cancellationToken);
}
SetServerHash(info.ManifestUri.ToString(), info.Hash);
_logger.Log("Fetching manifest from: " + info.ManifestUri);
loadingHandler.SetLoadingMessage("Fetching manifest from: " + info.ManifestUri);
loadingHandler.SetLoadingMessage("Fetching manifest from: " + info.ManifestUri.Host);
var response = await _http.GetAsync(info.ManifestUri, cancellationToken);
if (!response.IsSuccessStatusCode) throw new Exception();
response.EnsureSuccessStatusCode();
loadingHandler.SetJobsCount(response.Content.Headers.ContentLength ?? 0);
await using var streamContent = await response.Content.ReadAsStreamAsync(cancellationToken);
ManifestFileApi.Save(info.Hash, streamContent);
ManifestFileApi.Save(info.Hash, streamContent, loadingHandler);
loadingHandler.Dispose();
streamContent.Seek(0, SeekOrigin.Begin);
using var manifestReader = new ManifestReader(streamContent);
return await EnsureItems(manifestReader, info.DownloadUri, loadingHandler, cancellationToken);
return await EnsureItems(manifestReader, info.DownloadUri, loadingFactory, cancellationToken);
}
public void Unpack(HashApi hashApi, IWriteFileApi otherApi, ILoadingHandler loadingHandler)
@@ -107,30 +111,22 @@ public partial class ContentService
}
else
{
_logger.Error("OH FUCK!! " + item.Path);
_logger.Error("Error while unpacking thinks " + item.Path);
}
loadingHandler.AppendResolvedJob();
});
if (loadingHandler is IDisposable disposable)
{
disposable.Dispose();
}
}
public async Task Download(Uri contentCdn, List<RobustManifestItem> toDownload, HashApi hashApi, ILoadingHandler loadingHandler,
private async Task Download(Uri contentCdn, List<RobustManifestItem> toDownload, HashApi hashApi, ILoadingHandlerFactory loadingHandlerFactory,
CancellationToken cancellationToken)
{
if (toDownload.Count == 0 || cancellationToken.IsCancellationRequested)
{
_logger.Log("Nothing to download! Fuck this!");
_logger.Log("Nothing to download! Skip!");
return;
}
var downloadJobWatch = loadingHandler.GetQueryJob();
loadingHandler.SetLoadingMessage("Downloading from: " + contentCdn);
_logger.Log("Downloading from: " + contentCdn);
var requestBody = new byte[toDownload.Count * 4];
@@ -152,70 +148,56 @@ public partial class ContentService
request.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("zstd"));
var response = await _http.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
if (cancellationToken.IsCancellationRequested)
{
_logger.Log("Downloading cancelled!");
return;
}
downloadJobWatch.Dispose();
response.EnsureSuccessStatusCode();
var stream = await response.Content.ReadAsStreamAsync();
var bandwidthStream = new BandwidthStream(stream);
stream = bandwidthStream;
var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
if (response.Content.Headers.ContentEncoding.Contains("zstd"))
stream = new ZStdDecompressStream(stream);
await using var streamDispose = stream;
// Read flags header
var streamHeader = await stream.ReadExactAsync(4, null);
var streamHeader = await stream.ReadExactAsync(4, cancellationToken);
var streamFlags = (DownloadStreamHeaderFlags)BinaryPrimitives.ReadInt32LittleEndian(streamHeader);
var preCompressed = (streamFlags & DownloadStreamHeaderFlags.PreCompressed) != 0;
// compressContext.SetParameter(ZSTD_cParameter.ZSTD_c_nbWorkers, 4);
// If the stream is pre-compressed we need to decompress the blobs to verify BLAKE2B hash.
// If it isn't, we need to manually try re-compressing individual files to store them.
var compressContext = preCompressed ? null : new ZStdCCtx();
var decompressContext = preCompressed ? new ZStdDCtx() : null;
// Normal file header:
// <int32> uncompressed length
// When preCompressed is set, we add:
// <int32> compressed length
var fileHeader = new byte[preCompressed ? 8 : 4];
var downloadLoadHandler = loadingHandlerFactory.CreateLoadingContext();
downloadLoadHandler.SetJobsCount(toDownload.Count);
downloadLoadHandler.SetLoadingMessage("Fetching files...");
if (loadingHandlerFactory is IConnectionSpeedHandler speedHandlerStart)
speedHandlerStart.PasteSpeed(0);
try
{
// Buffer for storing compressed ZStd data.
var compressBuffer = new byte[1024];
// Buffer for storing uncompressed data.
var readBuffer = new byte[1024];
var i = 0;
loadingHandler.AppendJob(toDownload.Count);
var downloadWatchdog = new Stopwatch();
var lengthAcc = 0;
var timeAcc = 0L;
foreach (var item in toDownload)
{
if (cancellationToken.IsCancellationRequested)
{
_logger.Log("Downloading cancelled!");
decompressContext?.Dispose();
compressContext?.Dispose();
return;
}
cancellationToken.ThrowIfCancellationRequested();
downloadWatchdog.Restart();
// Read file header.
await stream.ReadExactAsync(fileHeader, null);
await stream.ReadExactAsync(fileHeader, cancellationToken);
var length = BinaryPrimitives.ReadInt32LittleEndian(fileHeader.AsSpan(0, 4));
var fileLoadingHandler = loadingHandlerFactory.CreateLoadingContext(new FileLoadingFormater());
fileLoadingHandler.SetLoadingMessage(item.Path.Split("/").Last());
var blockFileLoadHandle = length <= 100000;
EnsureBuffer(ref readBuffer, length);
var data = readBuffer.AsMemory(0, length);
@@ -226,9 +208,10 @@ public partial class ContentService
if (compressedLength > 0)
{
fileLoadingHandler.AppendJob(compressedLength);
EnsureBuffer(ref compressBuffer, compressedLength);
var compressedData = compressBuffer.AsMemory(0, compressedLength);
await stream.ReadExactAsync(compressedData, null);
await stream.ReadExactAsync(compressedData, cancellationToken, blockFileLoadHandle ? null : fileLoadingHandler);
// Decompress so that we can verify hash down below.
@@ -239,24 +222,53 @@ public partial class ContentService
}
else
{
await stream.ReadExactAsync(data, null);
fileLoadingHandler.AppendJob(length);
await stream.ReadExactAsync(data, cancellationToken, blockFileLoadHandle ? null : fileLoadingHandler);
}
}
else
{
await stream.ReadExactAsync(data, null);
fileLoadingHandler.AppendJob(length);
await stream.ReadExactAsync(data, cancellationToken, blockFileLoadHandle ? null : fileLoadingHandler);
}
using var fileStream = new MemoryStream(data.ToArray());
hashApi.Save(item, fileStream);
hashApi.Save(item, fileStream, null);
_logger.Log("file saved:" + item.Path);
loadingHandler.AppendResolvedJob();
fileLoadingHandler.Dispose();
downloadLoadHandler.AppendResolvedJob();
i += 1;
if (loadingHandlerFactory is not IConnectionSpeedHandler speedHandler)
continue;
if (downloadWatchdog.ElapsedMilliseconds + timeAcc < 1000)
{
timeAcc += downloadWatchdog.ElapsedMilliseconds;
lengthAcc += length;
continue;
}
if (timeAcc != 0)
{
timeAcc += downloadWatchdog.ElapsedMilliseconds;
lengthAcc += length;
speedHandler.PasteSpeed((int)(lengthAcc / (timeAcc / 1000)));
timeAcc = 0;
lengthAcc = 0;
continue;
}
speedHandler.PasteSpeed((int)(length / (downloadWatchdog.ElapsedMilliseconds / 1000)));
}
}
finally
{
downloadLoadHandler.Dispose();
decompressContext?.Dispose();
compressContext?.Dispose();
}

15
Nebula.Shared/Services/ContentService.Migration.cs
View File

@@ -5,7 +5,7 @@ namespace Nebula.Shared.Services;
public partial class ContentService
{
public bool CheckMigration(ILoadingHandler loadingHandler)
public bool CheckMigration(ILoadingHandlerFactory loadingHandler)
{
_logger.Log("Checking migration...");
@@ -17,16 +17,13 @@ public partial class ContentService
return true;
}
private void DoMigration(ILoadingHandler loadingHandler, List<string> migrationList)
private void DoMigration(ILoadingHandlerFactory loadingHandler, List<string> migrationList)
{
loadingHandler.SetJobsCount(migrationList.Count);
var mainLoadingHandler = loadingHandler.CreateLoadingContext();
mainLoadingHandler.SetJobsCount(migrationList.Count);
Parallel.ForEach(migrationList, (f,_)=>MigrateFile(f,loadingHandler));
if (loadingHandler is IDisposable disposable)
{
disposable.Dispose();
}
Parallel.ForEach(migrationList, (f,_)=>MigrateFile(f, mainLoadingHandler) );
loadingHandler.Dispose();
}
private void MigrateFile(string file, ILoadingHandler loadingHandler)

37
Nebula.Shared/Services/EngineService.cs
View File

@@ -108,11 +108,13 @@ public sealed class EngineService
return info != null;
}
public async Task<AssemblyApi?> EnsureEngine(string version)
public async Task<AssemblyApi?> EnsureEngine(string version, ILoadingHandlerFactory loadingHandlerFactory, CancellationToken cancellationToken = default)
{
_logger.Log("Ensure engine " + version);
using var loadingHandler = loadingHandlerFactory.CreateLoadingContext(new FileLoadingFormater());
loadingHandler.SetLoadingMessage("Ensuring engine " + version);
if (!TryOpen(version)) await DownloadEngine(version);
if (!TryOpen(version)) await DownloadEngine(version, loadingHandler, cancellationToken);
try
{
@@ -128,15 +130,24 @@ public sealed class EngineService
return null;
}
public async Task DownloadEngine(string version)
public async Task DownloadEngine(string version, ILoadingHandler loadingHandler, CancellationToken cancellationToken = default)
{
if (!TryGetVersionInfo(version, out var info))
return;
_logger.Log("Downloading engine version " + version);
loadingHandler.SetLoadingMessage("Downloading engine version " + version);
loadingHandler.Clear();
using var client = new HttpClient();
var s = await client.GetStreamAsync(info.Url);
_engineFileApi.Save(version, s);
var response = await client.GetAsync(info.Url, cancellationToken);
response.EnsureSuccessStatusCode();
loadingHandler.SetJobsCount(response.Content.Headers.ContentLength ?? 0);
await using var streamContent = await response.Content.ReadAsStreamAsync(cancellationToken);
var s = await client.GetStreamAsync(info.Url, cancellationToken);
_engineFileApi.Save(version, s, loadingHandler);
await s.DisposeAsync();
}
@@ -176,7 +187,7 @@ public sealed class EngineService
{
GetEngineInfo(out var modulesInfo, out var engineVersionInfo);
var engineVersionObj = Version.Parse(engineVersion);
var engineVersionObj = Version.Parse(engineVersion.Split("-")[0]);
var module = modulesInfo.Modules[moduleName];
var selectedVersion = module.Versions.Select(kv => new { Version = Version.Parse(kv.Key), kv.Key, kv })
.Where(kv => engineVersionObj >= kv.Version)
@@ -187,15 +198,18 @@ public sealed class EngineService
return selectedVersion.Key;
}
public async Task<AssemblyApi?> EnsureEngineModules(string moduleName, string engineVersion)
public async Task<AssemblyApi?> EnsureEngineModules(string moduleName, ILoadingHandlerFactory loadingHandlerFactory, string engineVersion)
{
var moduleVersion = ResolveModuleVersion(moduleName, engineVersion);
if (!TryGetModuleBuildInfo(moduleName, moduleVersion, out var buildInfo))
return null;
var fileName = ConcatName(moduleName, moduleVersion);
using var loadingHandler = loadingHandlerFactory.CreateLoadingContext(new FileLoadingFormater());
loadingHandler.SetLoadingMessage("Ensuring engine module " + fileName);
if (!TryOpen(fileName)) await DownloadEngineModule(moduleName, moduleVersion);
if (!TryOpen(fileName)) await DownloadEngineModule(moduleName, loadingHandler, moduleVersion);
try
{
@@ -210,19 +224,20 @@ public sealed class EngineService
}
}
public async Task DownloadEngineModule(string moduleName, string moduleVersion)
public async Task DownloadEngineModule(string moduleName, ILoadingHandler loadingHandler, string moduleVersion)
{
if (!TryGetModuleBuildInfo(moduleName, moduleVersion, out var info))
return;
_logger.Log("Downloading engine module version " + moduleVersion);
loadingHandler.SetLoadingMessage("Downloading engine module version " + moduleVersion);
using var client = new HttpClient();
var s = await client.GetStreamAsync(info.Url);
_engineFileApi.Save(ConcatName(moduleName, moduleVersion), s);
_engineFileApi.Save(ConcatName(moduleName, moduleVersion), s, loadingHandler);
await s.DisposeAsync();
}
public string ConcatName(string moduleName, string moduleVersion)
private string ConcatName(string moduleName, string moduleVersion)
{
return moduleName + "" + moduleVersion;
}

29
Nebula.Shared/Services/FileService.cs
View File

@@ -89,14 +89,26 @@ public class FileService
}
}
public sealed class ConsoleLoadingHandlerFactory : ILoadingHandlerFactory
{
public ILoadingHandler CreateLoadingContext(ILoadingFormater? loadingFormater = null)
{
return new ConsoleLoadingHandler();
}
public void Dispose()
{
}
}
public sealed class ConsoleLoadingHandler : ILoadingHandler
{
private int _currJobs;
private long _currJobs;
private float _percent;
private int _resolvedJobs;
private long _resolvedJobs;
public void SetJobsCount(int count)
public void SetJobsCount(long count)
{
_currJobs = count;
@@ -104,12 +116,12 @@ public sealed class ConsoleLoadingHandler : ILoadingHandler
Draw();
}
public int GetJobsCount()
public long GetJobsCount()
{
return _currJobs;
}
public void SetResolvedJobsCount(int count)
public void SetResolvedJobsCount(long count)
{
_resolvedJobs = count;
@@ -117,7 +129,7 @@ public sealed class ConsoleLoadingHandler : ILoadingHandler
Draw();
}
public int GetResolvedJobsCount()
public long GetResolvedJobsCount()
{
return _resolvedJobs;
}
@@ -154,4 +166,9 @@ public sealed class ConsoleLoadingHandler : ILoadingHandler
Console.Write($"\t {_resolvedJobs}/{_currJobs}");
}
public void Dispose()
{
}
}

5
Nebula.Shared/Services/RestService.cs
View File

@@ -29,10 +29,7 @@ public class RestService
[Pure]
public async Task<T> GetAsync<T>(Uri uri, CancellationToken cancellationToken) where T : notnull
{
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, uri)
{
Version = HttpVersion.Version10,
};
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, uri);
var response = await _client.SendAsync(httpRequestMessage, cancellationToken).ConfigureAwait(false);
return await ReadResult<T>(response, cancellationToken, uri);