public async Task <bool> TryToPack(AcCommonObjectPackerParams packerParams) { try { using (var waiting = packerParams.Progress == null ? WaitingDialog.Create("Packing…") : null) { var progress = waiting ?? packerParams.Progress; var cancellation = waiting?.CancellationToken ?? packerParams.Cancellation; await Task.Run(() => { var destination = packerParams.Destination ?? Path.Combine(Location, $"{Id}-{(this as IAcObjectVersionInformation)?.Version ?? "0"}-{DateTime.Now.ToUnixTimestamp()}.zip"); using (var output = File.Create(destination)) { Pack(output, packerParams, new Progress <string>(x => progress?.Report(AsyncProgressEntry.FromStringIndetermitate($"Packing: {x}…"))), cancellation); } if (cancellation.IsCancellationRequested) { return; } if (packerParams.ShowInExplorer) { WindowsHelper.ViewFile(destination); } }); } return(true); } catch (Exception e) { NonfatalError.Notify("Can’t pack", e); return(false); } }
public Task EnableMod(GenericMod mod) { return(_busy.Task(async() => { if (_enabler == null || mod.IsEnabled) { return; } var conflicts = await _enabler.CheckConflictsAsync(mod); if (conflicts.Length > 0 && ModernDialog.ShowMessage( conflicts.Select(x => $@"• “{Path.GetFileName(x.RelativeName)}” has already been altered by the “{x.ModName}” mod;") .JoinToString("\n").ToSentence () + $"\n\nEnabling {BbCodeBlock.Encode(mod.DisplayName)} may have adverse effects. Are you sure you want to enable this mod?", "Conflict", MessageBoxButton.YesNo, "genericMods.conflict") != MessageBoxResult.Yes) { return; } try { using (var waiting = WaitingDialog.Create("Enabling mod…")) { await _enabler.EnableAsync(mod, waiting, waiting.CancellationToken); Changed?.Invoke(this, EventArgs.Empty); if (waiting.CancellationToken.IsCancellationRequested) { waiting.Report(AsyncProgressEntry.FromStringIndetermitate("Cancellation…")); await _enabler.DisableAsync(mod); } } } catch (Exception e) { NonfatalError.Notify("Can’t enable mod", e); } })); }
void IUserPresetable.ImportFromPresetData(string data) { if (_enabler == null || Enabled == null || Disabled == null) { return; } _busy.Task(async() => { await Task.Delay(10); var names = data.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries); var enabled = Enabled.OfType <GenericMod>().OrderByDescending(x => x.AppliedOrder).ToList(); try { using (var waiting = WaitingDialog.Create("Loading mod profile…")) { for (var i = 0; i < enabled.Count; i++) { var mod = enabled[i]; waiting.Report(mod.DisplayName, i, enabled.Count); if (waiting.CancellationToken.IsCancellationRequested) { return; } await _enabler.DisableAsync(mod, null, waiting.CancellationToken); if (waiting.CancellationToken.IsCancellationRequested) { waiting.Report(AsyncProgressEntry.FromStringIndetermitate("Cancellation…")); await _enabler.EnableAsync(mod); } } for (var i = 0; i < names.Length; i++) { var mod = _enabler.GetByName(names[i]); if (mod == null) { continue; } waiting.Report(mod.DisplayName, i, enabled.Count); if (waiting.CancellationToken.IsCancellationRequested) { return; } await _enabler.EnableAsync(mod, null, waiting.CancellationToken); if (waiting.CancellationToken.IsCancellationRequested) { waiting.Report(AsyncProgressEntry.FromStringIndetermitate("Cancellation…")); await _enabler.DisableAsync(mod); } } } } catch (Exception e) { NonfatalError.Notify("Can’t load mod profile", e); } }).Forget(); }
private async Task <bool> FixAsync([NotNull] CarObject car, CarObject donor, IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default(CancellationToken)) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Fixing sound…")); await car.ReplaceSound(donor); return(true); }
private Func <IProgress <AsyncProgressEntry>, CancellationToken, Task <bool> > FixAsync([NotNull] CarObject car, CarObject donor) { return(async(p, c) => { p?.Report(AsyncProgressEntry.FromStringIndetermitate("Fixing sound…")); await car.ReplaceSound(donor); return true; }); }
protected override Task <bool> FixAsync(CarObject car, IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default(CancellationToken)) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Fixing car…")); var data = car.AcdData; if (data == null || data.IsEmpty) { return(Task.FromResult(false)); } Lut torque, power; try { torque = TorquePhysicUtils.LoadCarTorque(data); power = TorquePhysicUtils.TorqueToPower(torque); } catch (Exception e) { Logging.Error(e); return(Task.FromResult(false)); } var multipler = ActionExtension.InvokeInMainThread(() => { var dlg = new CarTransmissionLossSelector(car, torque.MaxY, power.MaxY); dlg.ShowDialog(); return(dlg.IsResultOk ? dlg.Multipler : (double?)null); }); if (!multipler.HasValue) { return(Task.FromResult(false)); } torque.TransformSelf(x => x.Y * multipler.Value); power.TransformSelf(x => x.Y * multipler.Value); if (car.SpecsTorqueCurve != null) { var torqueUi = new Lut(car.SpecsTorqueCurve.Points); torqueUi.TransformSelf(x => x.Y * multipler.Value); car.SpecsTorqueCurve = new GraphData(torqueUi); } if (car.SpecsPowerCurve != null) { var powerUi = new Lut(car.SpecsPowerCurve.Points); powerUi.TransformSelf(x => x.Y * multipler.Value); car.SpecsPowerCurve = new GraphData(powerUi); } car.SpecsTorque = SelectedAcObjectViewModel.SpecsFormat(AppStrings.CarSpecs_Torque_FormatTooltip, torque.MaxY.ToString(@"F0", CultureInfo.InvariantCulture)) + (multipler.Value == 1d ? "*" : ""); car.SpecsBhp = SelectedAcObjectViewModel.SpecsFormat(multipler.Value == 1d ? AppStrings.CarSpecs_PowerAtWheels_FormatTooltip : AppStrings.CarSpecs_Power_FormatTooltip, power.MaxY.ToString(@"F0", CultureInfo.InvariantCulture)); return(Task.FromResult(true)); }
protected override async Task <bool> LoadOverride(IProgress <AsyncProgressEntry> progress, CancellationToken cancellation) { if (_id != null) { var car = CarsManager.Instance.GetById(_id); if (car != null) { progress.Report(AsyncProgressEntry.Indetermitate); ObsoleteCars = new List <ObsoleteDetails> { await Task.Run(() => GetDetails(car, _models, true)) }; } else { ObsoleteCars = new List <ObsoleteDetails>(); } } else { var entries = new List <ObsoleteDetails>(); var filter = _filter == null ? null : Filter.Create(CarObjectTester.Instance, _filter); progress.Report(AsyncProgressEntry.FromStringIndetermitate("Loading cars…")); await CarsManager.Instance.EnsureLoadedAsync(); IEnumerable <CarObject> carsEnumerable = CarsManager.Instance.LoadedOnly.OrderBy(x => x.Name); if (filter != null) { carsEnumerable = carsEnumerable.Where(filter.Test); } var cars = carsEnumerable.ToList(); for (var i = 0; i < cars.Count; i++) { var car = cars[i]; progress.Report(new AsyncProgressEntry(car.Name, i, cars.Count)); try { var details = await Task.Run(() => GetDetails(car, _models, false)); if (details != null) { entries.Add(details); } } catch (Exception e) { NonfatalError.Notify($"Can’t check {car.DisplayName}", e); } } ObsoleteCars = entries; } return(ObsoleteCars.Count > 0); }
protected Task <bool> FixAsync([NotNull] CarObject car, Action <DataWrapper> action, IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default(CancellationToken)) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Fixing car…")); return(Task.Run(() => { var data = car.AcdData; if (data == null || data.IsEmpty) { return false; } action(data); return true; })); }
private static async Task <byte[]> GetFlamesTexturesAsync(IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default(CancellationToken)) { if (_flamesTextures == null) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Loading flames textures…")); _flamesTextures = await CmApiProvider.GetStaticDataBytesAsync("flames", TimeSpan.FromDays(3), cancellation : cancellation); if (cancellation.IsCancellationRequested) { return(null); } } return(_flamesTextures); }
public static async Task <bool> FixSuspensionNodesAsync(CarObject car, IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default(CancellationToken)) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Fixing car…")); return(await Task.Run(() => { var kn5Filename = FileUtils.GetMainCarFilename(car.Location, car.AcdData); if (kn5Filename == null || !File.Exists(kn5Filename)) { return false; } var kn5 = Kn5.FromFile(kn5Filename); FixSuspensionNodes(kn5); kn5.SaveRecyclingOriginal(kn5Filename); return true; })); }
public static async Task <bool> FixMissingTexturesAsync(CarObject car, IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default(CancellationToken)) { var flamesTextures = await GetFlamesTexturesAsync(progress, cancellation); if (cancellation.IsCancellationRequested) { return(false); } progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Unpacking textures…")); return(await Task.Run(() => { var flamesDirectory = Path.Combine(car.Location, @"texture", @"flames"); flamesTextures.ExtractAsArchiveTo(flamesDirectory); return true; })); }
private Task <bool> FixAsync([NotNull] CarObject car, Action <Kn5> fix, IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default(CancellationToken)) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Fixing car…")); return(Task.Run(() => { var kn5Filename = FileUtils.GetMainCarFilename(car.Location, car.AcdData); if (kn5Filename == null || !File.Exists(kn5Filename)) { return false; } var kn5 = Kn5.FromFile(kn5Filename); fix.Invoke(kn5); kn5.SaveRecyclingOriginal(kn5Filename); return true; })); }
public static async Task <bool> UpgradeToSecondVersionAsync(CarObject car, IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default(CancellationToken)) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Updating data…")); if (!await Task.Run(() => { var data = car.AcdData; if (data == null || data.IsEmpty) { return(false); } var flames = data.GetIniFile("flames.ini"); var header = flames["HEADER"]; header.Set("EDIT_BIG", false); header.Set("EDIT_STATE", 4); header.Set("BURN_FUEL_MULT", 10); header.Set("FLASH_THRESHOLD", 7); foreach (var section in flames.GetSections("FLAME")) { section.Set("IS_LEFT", section.GetVector3("POSITION").FirstOrDefault() < 0d); section.Set("GROUP", 0); } flames.Save(); Logging.Write($"Fixed: flames.ini of {car.DisplayName}"); var flamesPresetsEncoded = @"jdPBjoIwEAbgOwlvUjedgSJ74MDGgia4kFIPaja8/1s4BVdaW1IPcIDhy/Dzcz/K+iDVX5qMp5uczpdOV5AmaXIflBy" + @"lnkZdKz1xGtDq1LZSVTxN+qahexX/4ux54AKYS4JGr4M0c6r9qVAIBiVnIGgOfRosGgI0vGR4wmDByBnOk3tfRkvG0NLluvQ+sPTLLm1b/h6cO" + @"PJIHEVg628aWl7NdSG2cbG6+bbrhmFgjHw/8F0MuMJ2u74ftosBbEfn2V5jhsxdGrBkIpDFTG8Wg5pkbDR9Kj6xTWxv+GY3stnO6alMrLZwQ7Ft" + @"J5Omq8ejE0rwM3I/bqt4/2mDL8d+Fp59JLuBLHSsInb3Ap0mGpatHw=="; var flamesPresets = data.GetRawFile(@"flame_presets.ini"); flamesPresets.Content = Encoding.UTF8.GetString(new DeflateStream( new MemoryStream(Convert.FromBase64String(flamesPresetsEncoded)), CompressionMode.Decompress).ReadAsBytesAndDispose()); flamesPresets.Save(); Logging.Write($"Fixed: flame_presets.ini of {car.DisplayName}"); return(true); }) || cancellation.IsCancellationRequested) { return(false); } return(await FixMissingTexturesAsync(car, progress, cancellation)); }
public async Task <bool> LoadAsync(ListAddCallback <ServerInformation> callback, IProgress <AsyncProgressEntry> progress, CancellationToken cancellation) { if (SteamIdHelper.Instance.Value == null) { throw new Exception(ToolsStrings.Common_SteamIdIsMissing); } var data = await Task.Run(() => KunosApiProvider.TryToGetList(progress == null ? null : new ProgressConverter(progress)), cancellation); // if (cancellation.IsCancellationRequested) return false; if (data == null) { throw new InformativeException(ToolsStrings.Online_CannotLoadData, ToolsStrings.Common_MakeSureInternetWorks); } progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Applying list…")); callback(data); return(true); }
public Task DisableMod(GenericMod mod) { return(_busy.Task(async() => { if (_enabler == null || !mod.IsEnabled) { return; } try { using (var waiting = WaitingDialog.Create("Disabling mod…")) { await _enabler.DisableAsync(mod, waiting, waiting.CancellationToken); Changed?.Invoke(this, EventArgs.Empty); if (waiting.CancellationToken.IsCancellationRequested) { waiting.Report(AsyncProgressEntry.FromStringIndetermitate("Cancellation…")); await _enabler.EnableAsync(mod); } } } catch (Exception e) { NonfatalError.Notify("Can’t disable mod", e); } })); }
public async Task <WorkshopUploadResult> UploadAsync(byte[] data, string group, string name, IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default) { for (var i = 0; i < 3; ++i) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate(i == 0 ? "Starting upload…" : $"Trying again, {(i + 1).ToOrdinal("attempt").ToSentenceMember()} attempt")); try { return(await TryToUploadAsync()); } catch (HttpRequestException e) { Logging.Warning(e); cancellation.ThrowIfCancellationRequested(); progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Upload is failed, waiting a bit before the next attempt…")); await Task.Delay(TimeSpan.FromSeconds(i + 1d)); cancellation.ThrowIfCancellationRequested(); } catch (WebException e) { Logging.Warning(e); cancellation.ThrowIfCancellationRequested(); progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Upload is failed, waiting a bit before the next attempt…")); await Task.Delay(TimeSpan.FromSeconds(i + 1d)); cancellation.ThrowIfCancellationRequested(); } } cancellation.ThrowIfCancellationRequested(); progress?.Report(AsyncProgressEntry.FromStringIndetermitate($"Trying again, last attempt")); return(await TryToUploadAsync()); async Task <WorkshopUploadResult> TryToUploadAsync() { var request = new HttpRequestMessage(HttpMethod.Post, _endpoint); request.Headers.TryAddWithoutValidation("X-Data-File-Group", group); request.Headers.TryAddWithoutValidation("X-Data-File-Name", name); request.Headers.TryAddWithoutValidation("X-Data-Checksum", _checksum); var stopwatch = new AsyncProgressBytesStopwatch(); request.Content = progress == null ? (HttpContent) new ByteArrayContent(data) : new ProgressableByteArrayContent(data, 8192, new Progress <long>(x => progress.Report(AsyncProgressEntry.CreateUploading(x, data.Length, stopwatch)))); using (var response = await HttpClientHolder.Get().SendAsync(request, cancellation).ConfigureAwait(false)) { if (response.StatusCode != HttpStatusCode.OK) { throw new WebException($"Failed to upload: {response.StatusCode}, response: {await LoadContent()}"); } var result = JObject.Parse(await LoadContent()); return(new WorkshopUploadResult { Size = data.Length, Tag = result["key"].ToString() }); ConfiguredTaskAwaitable <string> LoadContent() { return(response.Content.ReadAsStringAsync().WithCancellation(cancellation).ConfigureAwait(false)); } } } }
public static async Task <string> LoadAsyncTo(string argument, FlexibleLoaderGetPreferredDestinationCallback getPreferredDestination, [CanBeNull] FlexibleLoaderReportDestinationCallback reportDestination, Action <FlexibleLoaderMetaInformation> reportMetaInformation = null, Func <bool> checkIfPaused = null, IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Finding fitting loader…")); var loader = await CreateLoaderAsync(argument, cancellation) ?? throw new OperationCanceledException(); try { using (var order = KillerOrder.Create(new CookieAwareWebClient(), TimeSpan.FromMinutes(10))) { var client = order.Victim; if (_proxy != null) { client.Proxy = _proxy; } progress?.Report(AsyncProgressEntry.Indetermitate); cancellation.ThrowIfCancellationRequested(); cancellation.Register(client.CancelAsync); if (!await loader.PrepareAsync(client, cancellation)) { throw new InformativeException("Can’t load file", "Loader preparation failed."); } cancellation.ThrowIfCancellationRequested(); reportMetaInformation?.Invoke(FlexibleLoaderMetaInformation.FromLoader(loader)); var initialProgressCallback = true; var reportStopwatch = Stopwatch.StartNew(); var progressStopwatch = new AsyncProgressBytesStopwatch(); if (loader.UsesClientToDownload) { client.DownloadProgressChanged += (sender, args) => { if (initialProgressCallback) { reportMetaInformation?.Invoke(FlexibleLoaderMetaInformation.FromLoader(loader)); initialProgressCallback = false; } if (reportStopwatch.Elapsed.TotalMilliseconds < 20) { return; } order.Delay(); reportStopwatch.Restart(); progress?.Report(AsyncProgressEntry.CreateDownloading(args.BytesReceived, args.TotalBytesToReceive == -1 && loader.TotalSize.HasValue ? Math.Max(loader.TotalSize.Value, args.BytesReceived) : args.TotalBytesToReceive, progressStopwatch)); }; } var loaded = await loader.DownloadAsync(client, getPreferredDestination, reportDestination, checkIfPaused, loader.UsesClientToDownload?null : new Progress <long>(p => { if (initialProgressCallback) { reportMetaInformation?.Invoke(FlexibleLoaderMetaInformation.FromLoader(loader)); initialProgressCallback = false; } if (reportStopwatch.Elapsed.TotalMilliseconds < 20) { return; } order.Delay(); reportStopwatch.Restart(); progress?.Report(loader.TotalSize.HasValue ? AsyncProgressEntry.CreateDownloading(p, loader.TotalSize.Value, progressStopwatch) : new AsyncProgressEntry(string.Format(UiStrings.Progress_Downloading, p.ToReadableSize(1)), null)); }), cancellation); cancellation.ThrowIfCancellationRequested(); Logging.Write("Loaded: " + loaded); return(loaded); } } catch (Exception e) when(cancellation.IsCancellationRequested || e.IsCancelled()) { Logging.Warning("Cancelled"); throw new OperationCanceledException(); } catch (Exception e) { Logging.Warning(e); throw; } }
public async Task <Scanned> GetEntriesAsync([NotNull] List <IFileInfo> list, string baseId, string baseName, [CanBeNull] IProgress <AsyncProgressEntry> progress, CancellationToken cancellation) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Scanning…")); var result = new List <ContentEntryBase>(); var missingContent = false; Exception readException = null; var s = Stopwatch.StartNew(); var root = new DirectoryNode(_installationParams.FallbackId ?? baseId, null); root.ForceName(baseName); foreach (var info in list) { root.Add(info); } Logging.Debug($"Building tree: {s.Elapsed.TotalMilliseconds:F1} ms"); s.Restart(); var queue = new Queue <DirectoryNode>(); queue.Enqueue(root); while (queue.Count > 0) { var directory = queue.Dequeue(); ContentEntryBase found; try { found = await CheckDirectoryNode(directory, cancellation).ConfigureAwait(false); // WHY IT DOES NOT WORK? if (cancellation.IsCancellationRequested) { break; } } catch (Exception e) when(e.IsCancelled()) { break; } catch (MissingContentException) { missingContent = true; continue; } catch (Exception e) { Logging.Warning(e); readException = e; continue; } if (found != null) { result.Add(found); } else { foreach (var value in directory.Directories) { queue.Enqueue(value); } foreach (var value in directory.Files) { try { found = await CheckFileNode(value, cancellation).ConfigureAwait(false); if (cancellation.IsCancellationRequested) { break; } } catch (Exception e) when(e.IsCancelled()) { break; } catch (MissingContentException) { missingContent = true; continue; } catch (Exception e) { Logging.Warning(e); readException = e; continue; } if (found != null) { result.Add(found); } } } } Logging.Debug($"Scanning directories: {s.Elapsed.TotalMilliseconds:F1} ms"); return(new Scanned(result, missingContent, readException)); }
public void Report(int value) { _target.Report(value == 0 ? AsyncProgressEntry.Indetermitate : AsyncProgressEntry.FromStringIndetermitate(string.Format(ToolsStrings.OnlineSource_Loading_Fallback, value + 1))); }
public async Task <IReadOnlyList <ServerInformationComplete> > ScanForServers(string address, IProgress <AsyncProgressEntry> progress, CancellationToken cancellation) { if (address == null) { throw new ArgumentNullException(nameof(address)); } // assume address is something like [HOSTNAME]:[HTTP PORT] if (!KunosApiProvider.ParseAddress(address, out var ip, out var port)) { throw new Exception(ToolsStrings.Online_CannotParseAddress); } if (port > 0) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate(ToolsStrings.Online_GettingInformationDirectly)); ServerInformationComplete information; try { information = await KunosApiProvider.GetInformationDirectAsync(ip, port); } catch (WebException) { if (cancellation.IsCancellationRequested) { return(null); } // assume address is [HOSTNAME]:[TCP PORT] progress?.Report(AsyncProgressEntry.FromStringIndetermitate(ToolsStrings.Online_TryingToFindOutHttpPort)); var pair = await KunosApiProvider.TryToPingServerAsync(ip, port, SettingsHolder.Online.PingTimeout); if (cancellation.IsCancellationRequested) { return(null); } if (pair != null) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate(ToolsStrings.Online_GettingInformationDirectly_SecondAttempt)); try { information = await KunosApiProvider.GetInformationDirectAsync(ip, pair.Item1); } catch (WebException) { information = null; } } else { information = null; } } if (cancellation.IsCancellationRequested) { return(null); } return(information == null ? new ServerInformationComplete[0] : new [] { information }); } else { var result = new List <ServerInformationComplete>(); // assume address is [HOSTNAME] progress?.Report(AsyncProgressEntry.FromStringIndetermitate(ToolsStrings.Common_Scanning)); var scanned = 0; var portsDiapason = PortsDiapason.Create(SettingsHolder.Online.PortsEnumeration); var total = portsDiapason.Count(); await portsDiapason.Select(async p => { var pair = await KunosApiProvider.TryToPingServerAsync(ip, p, SettingsHolder.Online.ScanPingTimeout); if (pair != null && pair.Item1 > 1024 && pair.Item1 < 65536) { if (cancellation.IsCancellationRequested) { return; } try { var information = await KunosApiProvider.GetInformationDirectAsync(ip, pair.Item1); if (cancellation.IsCancellationRequested) { return; } result.Add(information); } catch (WebException) { } } scanned++; progress?.Report(new AsyncProgressEntry(string.Format(ToolsStrings.Online_ScanningProgress, scanned, total, PluralizingConverter.PluralizeExt(result.Count, ToolsStrings.Online_ScanningProgress_Found)), scanned, total)); }).WhenAll(200, cancellation); return(result); } }
public async Task <WorkshopUploadResult> UploadAsync(byte[] data, string group, string name, IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Authorizing…")); await Authorize().WithCancellation(cancellation).ConfigureAwait(false); cancellation.ThrowIfCancellationRequested(); progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Finding a vault to upload…")); var uploadUrl = await _b2Client.Files.GetUploadUrl(cancelToken : cancellation); cancellation.ThrowIfCancellationRequested(); for (var i = 0; i < 4; ++i) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate(i == 0 ? "Starting upload…" : $"Trying again, {(i + 1).ToOrdinal("attempt").ToSentenceMember()} attempt")); try { return(await TryToUploadAsync(uploadUrl)); } catch (B2Exception e) when(e.Code == "bad_auth_token" || e.ShouldRetryRequest) { cancellation.ThrowIfCancellationRequested(); uploadUrl = await _b2Client.Files.GetUploadUrl(cancelToken : cancellation); } catch (HttpRequestException e) { Logging.Warning(e); cancellation.ThrowIfCancellationRequested(); progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Target vault is not available, waiting a bit before the next attempt…")); await Task.Delay(TimeSpan.FromSeconds(i + 1d)); cancellation.ThrowIfCancellationRequested(); } catch (WebException e) { Logging.Warning(e); cancellation.ThrowIfCancellationRequested(); progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Target vault is not available, waiting a bit before the next attempt…")); await Task.Delay(TimeSpan.FromSeconds(i + 1d)); cancellation.ThrowIfCancellationRequested(); } catch (B2Exception e) when(e.Status == "500" || e.Status == "503") { Logging.Warning(e); cancellation.ThrowIfCancellationRequested(); progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Target vault is not full, waiting a bit before the next attempt…")); await Task.Delay(TimeSpan.FromSeconds(i + 1d)); cancellation.ThrowIfCancellationRequested(); } catch (B2Exception e) { Logging.Warning("B2Exception.Code=" + e.Code); Logging.Warning("B2Exception.Status=" + e.Status); Logging.Warning("B2Exception.Message=" + e.Message); Logging.Warning("B2Exception.ShouldRetryRequest=" + e.ShouldRetryRequest); throw; } } cancellation.ThrowIfCancellationRequested(); progress?.Report(AsyncProgressEntry.FromStringIndetermitate($"Trying again, last attempt")); return(await TryToUploadAsync(uploadUrl)); async Task <WorkshopUploadResult> TryToUploadAsync(B2UploadUrl url) { var fileName = _b2ClientPrefix + group + "/" + name; var stopwatch = new AsyncProgressBytesStopwatch(); var file = await _b2Client.Files.Upload(data, fileName, url, "", "", new Dictionary <string, string> { ["b2-content-disposition"] = Regex.IsMatch(name, @"\.(png|jpg)$") ? "inline" : "attachment", ["b2-cache-control"] = "immutable" }, progress == null?null : new Progress <long>(x => progress.Report(AsyncProgressEntry.CreateUploading(x, data.Length, stopwatch))), cancellation).ConfigureAwait(false); return(new WorkshopUploadResult { Tag = JsonConvert.SerializeObject(new { fileName = file.FileName, fileID = file.FileId }), Size = data.LongLength }); } }
private static async Task ShowCarInShowroomAsync(string carId) { if (_showingCarInShowroom) { return; } _showingCarInShowroom = true; try { var temporaryDirectory = FilesStorage.Instance.GetTemporaryDirectory("Workshop", "Showroom", carId); var temporaryFilename = Path.Combine(temporaryDirectory, "data.zip"); byte[] modelData = null; string mainSkidId = null; var carData = new VirtualDataWrapper(); using (var waiting = WaitingDialog.Create("Loading showroom…")) { await WorkshopHolder.Client.DownloadFileAsync($"/cars/{carId}/download-showroom", temporaryFilename, false, waiting, waiting.CancellationToken); waiting.Report(AsyncProgressEntry.FromStringIndetermitate("Loading…")); await Task.Run(() => { using (var stream = File.OpenRead(temporaryFilename)) using (var archive = new ZipArchive(stream)) { foreach (var entry in archive.Entries) { if (entry.Length == 0) { continue; } if (entry.FullName == @"model.kn5") { modelData = entry.Open().ReadAsBytesAndDispose(); } else if (entry.FullName.StartsWith(@"data")) { carData.Data[Path.GetFileName(entry.FullName)] = entry.Open().ReadAsStringAndDispose(); } else { if (mainSkidId == null && entry.FullName.StartsWith(@"skins")) { mainSkidId = Path.GetFileName(Path.GetDirectoryName(entry.FullName)); } var newFilename = Path.Combine(temporaryDirectory, entry.FullName); FileUtils.EnsureFileDirectoryExists(newFilename); entry.ExtractToFile(newFilename, true); } waiting.CancellationToken.ThrowIfCancellationRequested(); } } }); waiting.CancellationToken.ThrowIfCancellationRequested(); } if (modelData == null) { throw new Exception("Model is missing"); } if (mainSkidId == null) { throw new Exception("Skins are missing"); } var description = CarDescription.FromKn5(Kn5.FromBytes(modelData), temporaryDirectory, carData); var renderer = new DarkKn5ObjectRenderer(description) { FlatMirror = true, FlatMirrorReflectiveness = 0.3f, FlatMirrorReflectedLight = true, BackgroundColor = Color.White, BackgroundBrightness = 0.05f, LightBrightness = 2f, AmbientBrightness = 2f, AmbientUp = Color.FromArgb(0xEEEEEE), AmbientDown = Color.FromArgb(0x333333), UseDof = true, UseAccumulationDof = true, AccumulationDofIterations = 40, AccumulationDofApertureSize = 0f, UseSslr = true, VisibleUi = false, UseSprite = false, AnyGround = false, ToneMapping = ToneMappingFn.Uncharted2, ToneExposure = 1.2f, ToneGamma = 1f, ToneWhitePoint = 2.2f, }; renderer.SelectSkin(mainSkidId); await FormWrapperBase.PrepareAsync(); var wrapper = new LiteShowroomFormWrapper(renderer); wrapper.Form.Icon = AppIconService.GetAppIcon(); CustomShowroomWrapper.SetProperties(wrapper, renderer); wrapper.Run(); } catch (Exception e) when(!e.IsCancelled()) { Logging.Warning(e); NonfatalError.Notify("Failed to load showroom", e); } finally { _showingCarInShowroom = false; } }
public void Report(int value) { _target.Report(value == 0 ? AsyncProgressEntry.Indetermitate : AsyncProgressEntry.FromStringIndetermitate($"Fallback to server #{value + 1}")); }
private async Task RunWrapper(string serverExecutable, ICollection <string> log, IProgress <AsyncProgressEntry> progress, CancellationToken cancellation) { progress.Report(AsyncProgressEntry.FromStringIndetermitate("Loading wrapper…")); var wrapperFilename = await LoadWinWrapper(cancellation); if (cancellation.IsCancellationRequested) { return; } if (wrapperFilename == null) { throw new InformativeException("Can’t run server", "Can’t load server wrapper."); } try { using (var process = ProcessExtension.Start(wrapperFilename, new[] { "-e", serverExecutable, $"presets/{Id}" }, new ProcessStartInfo { UseShellExecute = false, WorkingDirectory = Path.GetDirectoryName(serverExecutable) ?? "", RedirectStandardOutput = true, CreateNoWindow = true, RedirectStandardError = true, StandardOutputEncoding = Encoding.UTF8, StandardErrorEncoding = Encoding.UTF8, })) { process.Start(); SetRunning(process); ChildProcessTracker.AddProcess(process); progress?.Report(AsyncProgressEntry.Finished); process.BeginOutputReadLine(); process.BeginErrorReadLine(); process.OutputDataReceived += (sender, args) => { if (!string.IsNullOrWhiteSpace(args.Data)) { ActionExtension.InvokeInMainThread(() => log.Add(Regex.Replace(args.Data, @"\b(WARNING: .+)", @"[color=#ff8800]$1[/color]"))); } }; process.ErrorDataReceived += (sender, args) => { if (!string.IsNullOrWhiteSpace(args.Data)) { ActionExtension.InvokeInMainThread(() => log.Add($@"[color=#ff0000]{args.Data}[/color]")); } }; await process.WaitForExitAsync(cancellation); if (!process.HasExitedSafe()) { process.Kill(); } log.Add($@"[CM] Stopped: {process.ExitCode}"); } } finally { SetRunning(null); } }
private static async Task <IReadOnlyList <ExtraOption> > GetGbwRelatedExtraOptions(ContentEntryBase[] entries) { const string gbwWeatherPart = "_gbW_"; const string gbwPpFilterPart = "__gbW"; if (!entries.Any(x => x.Id.Contains(gbwWeatherPart))) { // This is not the GBW pack return(new ExtraOption[0]); } var gbwWeatherIds = entries.Where(x => x.Id.Contains(gbwWeatherPart) && x is WeatherContentEntry) .Select(x => x.Id).ToList(); if (gbwWeatherIds.Count < 10) { // It contains some GBW weather, but not a lot — not the pack return(new ExtraOption[0]); } await WeatherManager.Instance.EnsureLoadedAsync(); // Now, when data is loaded, we’re ready to create some extra options IEnumerable <ExtraOption> GetOptions() { { var installedWeatherIds = WeatherManager.Instance.WrappersList.Select(x => x.Id).Where(x => x.Contains(gbwWeatherPart)).ToList(); var obsoleteWeatherIds = installedWeatherIds.ApartFrom(gbwWeatherIds).ToList(); if (obsoleteWeatherIds.Count > 0) { var obsoleteLine = obsoleteWeatherIds.Select(x => $"“{WeatherManager.Instance.GetById(x)?.DisplayName ?? x}”") .JoinToReadableString(); yield return(new ExtraOption("Remove obsolete GBW weather", $"Installed, but not found here: {obsoleteLine}.", async(progress, cancellation) => { progress.Report(AsyncProgressEntry.FromStringIndetermitate("Removing obsolete GBW weather…")); await WeatherManager.Instance.EnsureLoadedAsync(); await WeatherManager.Instance.DeleteAsync(obsoleteWeatherIds); }, activeByDefault: true)); } } { var gbwPpFilterIds = entries.Where(x => x.Id.Contains(gbwPpFilterPart) && x is PpFilterContentEntry) .Select(x => x.Id).ToList(); var installedPpFilterIds = PpFiltersManager.Instance.WrappersList.Select(x => x.Id).Where(x => x.Contains(gbwPpFilterPart)).ToList(); var obsoletePpFilterIds = installedPpFilterIds.ApartFrom(gbwPpFilterIds).ToList(); if (obsoletePpFilterIds.Count > 0) { var obsoleteLine = obsoletePpFilterIds.Select(x => $"“{PpFiltersManager.Instance.GetById(x)?.DisplayName ?? x}”") .JoinToReadableString(); yield return(new ExtraOption("Remove obsolete GBW PP-filters", $"Installed, but not found here: {obsoleteLine}.", async(progress, cancellation) => { progress.Report(AsyncProgressEntry.FromStringIndetermitate("Removing obsolete GBW PP-filters…")); await PpFiltersManager.Instance.EnsureLoadedAsync(); await PpFiltersManager.Instance.DeleteAsync(obsoletePpFilterIds); }, activeByDefault: true)); } } } return(GetOptions().ToList()); }
private async Task RunShootingProcess(bool manualMode = false) { if (SelectedShowroom == null) { if (ShowMessage(AppStrings.CarPreviews_ShowroomIsMissingOptions, AppStrings.Common_OneMoreThing, MessageBoxButton.YesNo) == MessageBoxResult.Yes) { SelectPhase(Phase.Options); } else { _cancelled = true; Top = -9999; await Task.Delay(1); Close(); } return; } if (SelectedFilter == null) { if (ShowMessage(AppStrings.CarPreviews_FilterIsMissingOptions, AppStrings.Common_OneMoreThing, MessageBoxButton.YesNo) == MessageBoxResult.Yes) { SelectPhase(Phase.Options); } else { _cancelled = true; Top = -9999; await Task.Delay(1); Close(); } return; } if (_toUpdate.Any(u => !u.Car.Enabled || u.Skins?.Any(x => x.Enabled == false) == true)) { SelectPhase(Phase.Error, AppStrings.CarPreviews_CannotUpdateForDisabled); return; } Progress = AsyncProgressEntry.FromStringIndetermitate(UiStrings.Common_PleaseWait); SelectPhase(Phase.Waiting); _cancellationTokenSource = new CancellationTokenSource(); try { string filterId; var builtInPpFilter = SelectedFilter as BuiltInPpFilter; if (builtInPpFilter != null) { builtInPpFilter.EnsureInstalled(); filterId = builtInPpFilter.Name; } else { var filterObject = SelectedFilter as PpFilterObject; filterId = filterObject?.Name; } var begin = DateTime.Now; if (_toUpdate.Count > 1 && !ApplyImmediately) { throw new Exception("Can’t apply previews later if there are more than one car"); } for (var i = 0; i < _toUpdate.Count; i++) { var toUpdate = _toUpdate[i]; SeriesProgress = new AsyncProgressEntry(toUpdate.Car.DisplayName, i, _toUpdate.Count); await ShootCar(toUpdate, filterId, manualMode, ApplyImmediately, _cancellationTokenSource.Token); if (_cancellationTokenSource.IsCancellationRequested) { SelectPhase(Phase.Error, AppStrings.CarPreviews_CancelledMessage); return; } } TakenTime = DateTime.Now - begin; SelectPhase(ApplyImmediately ? Phase.ResultSummary : Phase.Result); } catch (ShotingCancelledException e) { SelectPhase(Phase.Error, e.UserCancelled ? AppStrings.CarPreviews_CancelledMessage : e.Message); if (!e.UserCancelled) { Logging.Warning("Cannot update previews: " + e); } } catch (ProcessExitedException e) { SelectPhase(Phase.Error, e.Message, AcLogHelper.TryToDetermineWhatsGoingOn()); Logging.Warning("Cannot update previews: " + e); } catch (Exception e) { SelectPhase(Phase.Error, e.Message); Logging.Warning("Cannot update previews: " + e); } }
protected override Task <bool> FixAsync(CarObject car, IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default(CancellationToken)) { progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Fixing car…")); return(CarReplaceTyresDialog.Run(car)); }