Add wingman re-ping after unsuccessful log uploads

Plenyx · Plenyx · commit d12c3704a132 · 2026-01-27T00:35:41.000+01:00
diff --git a/Forms/FormMain.cs b/Forms/FormMain.cs
@@ -57,7 +57,7 @@ public partial class FormMain : Form
     private readonly FormLogSession logSessionLink;
     private readonly FormPings pingsLink;
     private readonly FormTeams teamsLink;
-    private readonly Timer timerFailedLogsReupload = new()
+    private readonly Timer timerFailedLogsReuploadAndRePing = new()
     {
         Enabled = false,
         Interval = 900000,
@@ -324,7 +324,7 @@ internal FormMain()
             logSessionLink.checkBoxOnlySuccess.CheckedChanged += logSessionLink.CheckBoxOnlySuccess_CheckedChanged;
             logSessionLink.checkBoxSaveToFile.CheckedChanged += logSessionLink.CheckBoxSaveToFile_CheckedChanged;
             discordWebhooksLink.checkBoxShortenThousands.CheckedChanged += discordWebhooksLink.CheckBoxShortenThousands_CheckedChanged;
-            timerFailedLogsReupload.Elapsed += TimerFailedLogsReupload_Elapsed;
+            timerFailedLogsReuploadAndRePing.Elapsed += TimerFailedLogsReuploadAndRePingElapsed;
             timerCheckUpdate.Elapsed += TimerCheckUpdate_Elapsed;
             ApplicationSettings.Current.Save();
         }
@@ -634,6 +634,7 @@ private async Task StartUpAndCommandArgs()
         if (args.Length <= 1)
         {
             HandleLogReuploads();
+            HandleWingmanRePings();
             return;
         }
         var argIndex = -1;
@@ -667,32 +668,33 @@ private async Task StartUpAndCommandArgs()
             if (File.Exists(arg) && (arg.EndsWith(".evtc") || arg.EndsWith(".zevtc")))
             {
                 var archived = false;
-                var zipfilelocation = arg;
+                var zipFileLocation = arg;
                 if (!arg.EndsWith(".zevtc"))
                 {
-                    zipfilelocation = $"{ApplicationSettings.LocalDir}{Path.GetFileNameWithoutExtension(arg)}.zevtc";
-                    using var zipfile = ZipFile.Open(zipfilelocation, ZipArchiveMode.Create);
-                    zipfile.CreateEntryFromFile(arg, Path.GetFileName(arg));
+                    zipFileLocation = $"{ApplicationSettings.LocalDir}{Path.GetFileNameWithoutExtension(arg)}.zevtc";
+                    using var zipFile = ZipFile.Open(zipFileLocation, ZipArchiveMode.Create);
+                    zipFile.CreateEntryFromFile(arg, Path.GetFileName(arg));
                     archived = true;
                 }
                 try
                 {
-                    await HttpUploadLogAsync(zipfilelocation, defaultPostData);
+                    await HttpUploadLogAsync(zipFileLocation, defaultPostData);
                 }
                 catch
                 {
-                    AddToText($">>> Unknown error uploading a log: {zipfilelocation}");
+                    AddToText($">>> Unknown error uploading a log: {zipFileLocation}");
                 }
                 finally
                 {
                     if (archived)
                     {
-                        File.Delete(zipfilelocation);
+                        File.Delete(zipFileLocation);
                     }
                 }
             }
         }
         HandleLogReuploads();
+        HandleWingmanRePings();
     }
 
     private async Task ValidateGw2Tokens()
@@ -787,19 +789,19 @@ private async Task HttpUploadLogAsync(string file, Dictionary<string, string> po
                                 if (reportJson?.Error?.Contains("EI Failure") ?? false)
                                 {
                                     AddToText(">:> Due to an Elite Insights error while processing the log file, it will not be automatically reuploaded. Is the log file corrupted?");
-                                    LogReuploader.RemovedLogAndSave(file);
+                                    LogReuploader.RemoveLogAndSave(file);
                                     return;
                                 }
                                 if (reportJson?.Error?.Contains("An identical file was uploaded recently") ?? false)
                                 {
                                     AddToText(">:> To prevent same log regeneration, the upload try will not be automatically reuploaded.");
-                                    LogReuploader.RemovedLogAndSave(file);
+                                    LogReuploader.RemoveLogAndSave(file);
                                     return;
                                 }
                                 if (reportJson?.Error?.Contains("Encounter is too short") ?? false)
                                 {
                                     AddToText(">:> Encounter is too short to generate a valid log, the upload try will not be automatically reuploaded.");
-                                    LogReuploader.RemovedLogAndSave(file);
+                                    LogReuploader.RemoveLogAndSave(file);
                                     return;
                                 }
                             }
@@ -827,7 +829,7 @@ private async Task HttpUploadLogAsync(string file, Dictionary<string, string> po
                         }
                         LogReuploader.FailedLogs.Add(file);
                         LogReuploader.SaveFailedLogs();
-                        EnsureReuploadTimerStart();
+                        EnsureReuploadAndRePingTimerStart();
                         return;
                     }
                     AddToText($">:> Unable to upload file {Path.GetFileName(file)}, dps.report responded with an non-ok status code ({(int)responseMessage.StatusCode}).");
@@ -924,7 +926,7 @@ private async Task HttpUploadLogAsync(string file, Dictionary<string, string> po
                     // report success
                     AddToText($">:> {Path.GetFileName(file)} successfully uploaded.");
                     // remove from failed logs if present
-                    LogReuploader.RemovedLogAndSave(file);
+                    LogReuploader.RemoveLogAndSave(file);
                 }
                 catch (Exception e)
                 {
@@ -954,7 +956,7 @@ private async Task HandleQuickLogUploadRetry(string file, Dictionary<string, str
                 AddToText($">:> Upload retry failed 4 times for {Path.GetFileName(file)}, will try again during log reupload timer.");
                 LogReuploader.FailedLogs.Add(file);
                 LogReuploader.SaveFailedLogs();
-                EnsureReuploadTimerStart();
+                EnsureReuploadAndRePingTimerStart();
             }
             else
             {
@@ -984,11 +986,7 @@ private async Task ExecuteAllDiscordWebhooks(DpsReportJson reportJson, List<LogP
     {
         if (logSessionLink.SessionRunning)
         {
-            if (logSessionLink.checkBoxOnlySuccess.Checked && (reportJson.Encounter.Success ?? false))
-            {
-                SessionLogs.Add(reportJson);
-            }
-            else if (!logSessionLink.checkBoxOnlySuccess.Checked)
+            if ((logSessionLink.checkBoxOnlySuccess.Checked && (reportJson.Encounter.Success ?? false)) || !logSessionLink.checkBoxOnlySuccess.Checked)
             {
                 SessionLogs.Add(reportJson);
             }
@@ -1045,7 +1043,23 @@ private async Task CrossUploadToWingman(string file, DpsReportJsonExtraJson extr
         {
             return;
         }
-        AddToText(await Gw2WingmanUploader.Upload(file, extraJson));
+        var resultText = await Gw2WingmanUploader.Upload(file, extraJson);
+        if (resultText.Contains("fail") && !resultText.Contains("exists"))
+        {
+            WingmanRePing.LogsToPing.Add(new WingmanPingInfo
+            {
+                FilePath = file,
+                TriggerId = extraJson.TriggerId,
+                UploadedBy = extraJson.RecordedByAccountName,
+            });
+            WingmanRePing.SaveLogsToPing();
+            EnsureReuploadAndRePingTimerStart();
+        }
+        else
+        {
+            WingmanRePing.RemoveLogAndSave(file);
+        }
+        AddToText(resultText);
     }
 
     internal bool IsTwitchConnectionNull() => chatConnect is null;
@@ -1706,18 +1720,19 @@ private void TimerCheckUpdate_Elapsed(object sender, EventArgs e)
         _ = NewReleaseCheckAsync(false, true);
     }
 
-    private void TimerFailedLogsReupload_Elapsed(object sender, EventArgs e)
+    private void TimerFailedLogsReuploadAndRePingElapsed(object sender, EventArgs e)
     {
         HandleLogReuploads();
+        HandleWingmanRePings();
     }
 
-    private void EnsureReuploadTimerStart()
+    private void EnsureReuploadAndRePingTimerStart()
     {
-        if (timerFailedLogsReupload.Enabled)
+        if (timerFailedLogsReuploadAndRePing.Enabled)
         {
             return;
         }
-        timerFailedLogsReupload.Start();
+        timerFailedLogsReuploadAndRePing.Start();
     }
 
     private void HandleLogReuploads()
@@ -1731,6 +1746,17 @@ private void HandleLogReuploads()
         AddToText(">:> Log reuploading has ended.");
     }
 
+    private void HandleWingmanRePings()
+    {
+        if (WingmanRePing.LogsToPing.Count == 0)
+        {
+            return;
+        }
+        AddToText($">:> Starting wingman re-pings of {WingmanRePing.LogsToPing.Count} logs...");
+        WingmanRePing.ProcessLogs(semaphore, CrossUploadToWingman);
+        AddToText(">:> Wingman re-pings has been completed.");
+    }
+
     private void ComboBoxMaxUploads_SelectedIndexChanged(object sender, EventArgs e)
     {
         if (!int.TryParse(comboBoxMaxUploads.Text, out var threads))
diff --git a/Tools/LogReuploader.cs b/Tools/LogReuploader.cs
@@ -2,7 +2,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using ZLinq;
@@ -24,24 +23,28 @@ internal static HashSet<string> FailedLogs
     {
         get
         {
-            if (_failedLogs is null)
+            if (_failedLogs is not null)
             {
-                if (File.Exists(FileLocation))
+                return _failedLogs;
+            }
+            if (File.Exists(FileLocation))
+            {
+                try
                 {
-                    try
-                    {
-                        _failedLogs = File.ReadAllLines(FileLocation).Where(File.Exists).ToHashSet();
-                    }
-                    catch
-                    {
-                        _failedLogs = [];
-                    }
+                    _failedLogs = File.ReadAllLines(FileLocation)
+                        .AsValueEnumerable()
+                        .Where(File.Exists)
+                        .ToHashSet();
                 }
-                else
+                catch
                 {
                     _failedLogs = [];
                 }
             }
+            else
+            {
+                _failedLogs = [];
+            }
             return _failedLogs;
         }
     }
@@ -58,7 +61,7 @@ internal static void SaveFailedLogs()
         }
     }
 
-    internal static bool RemovedLogAndSave(string file)
+    internal static bool RemoveLogAndSave(string file)
     {
         var removed = FailedLogs.Remove(file);
         if (removed)
@@ -70,7 +73,7 @@ internal static bool RemovedLogAndSave(string file)
 
     internal static void ProcessLogs(SemaphoreSlim semaphore, Func<string, Dictionary<string, string>, bool, Task> process)
     {
-        foreach (var fileName in FailedLogs.ToArray().AsValueEnumerable())
+        foreach (var fileName in FailedLogs.AsValueEnumerable())
         {
             if (!File.Exists(fileName))
             {
@@ -79,7 +82,7 @@ internal static void ProcessLogs(SemaphoreSlim semaphore, Func<string, Dictionar
             }
             _ = Task.Run(async () =>
             {
-                semaphore.Wait();
+                await semaphore.WaitAsync();
                 await process(fileName, PostData, true);
                 semaphore.Release();
             });
diff --git a/Tools/WingmanPingInfo.cs b/Tools/WingmanPingInfo.cs
@@ -0,0 +1,15 @@
+using Newtonsoft.Json;
+
+namespace PlenBotLogUploader.Tools;
+
+public sealed class WingmanPingInfo
+{
+    [JsonProperty("filePath")]
+    internal string FilePath { get; set; }
+    
+    [JsonProperty("triggerID")]
+    internal int TriggerId { get; set; }
+    
+    [JsonProperty("uploadedBy")]
+    internal string UploadedBy { get; set; }
+}
diff --git a/Tools/WingmanRePing.cs b/Tools/WingmanRePing.cs
@@ -0,0 +1,100 @@
+using Newtonsoft.Json;
+using PlenBotLogUploader.AppSettings;
+using PlenBotLogUploader.DpsReport;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using ZLinq;
+
+namespace PlenBotLogUploader.Tools;
+
+public static class WingmanRePing
+{
+    private static readonly string FileLocation = $@"{ApplicationSettings.LocalDir}\wingmanreping.json";
+    
+    private static HashSet<WingmanPingInfo> _logsToPing;
+
+    internal static HashSet<WingmanPingInfo> LogsToPing
+    {
+        get
+        {
+            if (_logsToPing is not null)
+            {
+                return _logsToPing;
+            }
+            if (File.Exists(FileLocation))
+            {
+                try
+                {
+                    _logsToPing = JsonConvert.DeserializeObject<List<WingmanPingInfo>>(File.ReadAllText(FileLocation))
+                        .AsValueEnumerable()
+                        .Where(x => File.Exists(x.FilePath))
+                        .ToHashSet();
+                }
+                catch
+                {
+                    _logsToPing = [];
+                }
+            }
+            else
+            {
+                _logsToPing = [];
+            }
+            return _logsToPing;
+        }
+    }
+    
+    internal static void SaveLogsToPing()
+    {
+        try
+        {
+            File.WriteAllText(FileLocation, JsonConvert.SerializeObject(LogsToPing, Formatting.Indented));
+        }
+        catch
+        {
+            // do nothing
+        }
+    }
+
+    internal static void RemoveLogAndSave(string file)
+    {
+        var logToRemove = LogsToPing
+            .AsValueEnumerable()
+            .FirstOrDefault(x => file.Equals(x.FilePath) && File.Exists(x.FilePath));
+        if (logToRemove is null)
+        {
+            return;
+        }
+        var removed = LogsToPing.Remove(logToRemove);
+        if (removed)
+        {
+            SaveLogsToPing();
+        }
+        return;
+    }
+
+    internal static void ProcessLogs(SemaphoreSlim semaphore, Func<string, DpsReportJsonExtraJson, Task> process)
+    {
+        foreach (var wingmanPingInfo in LogsToPing.AsValueEnumerable())
+        {
+            if (!File.Exists(wingmanPingInfo.FilePath))
+            {
+                LogsToPing.Remove(wingmanPingInfo);
+                continue;
+            }
+            _ = Task.Run(async () =>
+            {
+                var convertedExtraJson = new DpsReportJsonExtraJson()
+                {
+                    TriggerId = wingmanPingInfo.TriggerId,
+                    RecordedByAccountName = wingmanPingInfo.UploadedBy,
+                };
+                await semaphore.WaitAsync();
+                await process(wingmanPingInfo.FilePath, convertedExtraJson);
+                semaphore.Release();
+            });
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ public partial class FormMain : Form`
`57`	`57`	`private readonly FormLogSession logSessionLink;`
`58`	`58`	`private readonly FormPings pingsLink;`
`59`	`59`	`private readonly FormTeams teamsLink;`
`60`		`- private readonly Timer timerFailedLogsReupload = new()`
	`60`	`+ private readonly Timer timerFailedLogsReuploadAndRePing = new()`
`61`	`61`	`{`
`62`	`62`	`Enabled = false,`
`63`	`63`	`Interval = 900000,`
`@@ -324,7 +324,7 @@ internal FormMain()`
`324`	`324`	`logSessionLink.checkBoxOnlySuccess.CheckedChanged += logSessionLink.CheckBoxOnlySuccess_CheckedChanged;`
`325`	`325`	`logSessionLink.checkBoxSaveToFile.CheckedChanged += logSessionLink.CheckBoxSaveToFile_CheckedChanged;`
`326`	`326`	`discordWebhooksLink.checkBoxShortenThousands.CheckedChanged += discordWebhooksLink.CheckBoxShortenThousands_CheckedChanged;`
`327`		`- timerFailedLogsReupload.Elapsed += TimerFailedLogsReupload_Elapsed;`
	`327`	`+ timerFailedLogsReuploadAndRePing.Elapsed += TimerFailedLogsReuploadAndRePingElapsed;`
`328`	`328`	`timerCheckUpdate.Elapsed += TimerCheckUpdate_Elapsed;`
`329`	`329`	`ApplicationSettings.Current.Save();`
`330`	`330`	`}`
`@@ -634,6 +634,7 @@ private async Task StartUpAndCommandArgs()`
`634`	`634`	`if (args.Length <= 1)`
`635`	`635`	`{`
`636`	`636`	`HandleLogReuploads();`
	`637`	`+ HandleWingmanRePings();`
`637`	`638`	`return;`
`638`	`639`	`}`
`639`	`640`	`var argIndex = -1;`
`@@ -667,32 +668,33 @@ private async Task StartUpAndCommandArgs()`
`667`	`668`	`if (File.Exists(arg) && (arg.EndsWith(".evtc") \|\| arg.EndsWith(".zevtc")))`
`668`	`669`	`{`
`669`	`670`	`var archived = false;`
`670`		`- var zipfilelocation = arg;`
	`671`	`+ var zipFileLocation = arg;`
`671`	`672`	`if (!arg.EndsWith(".zevtc"))`
`672`	`673`	`{`
`673`		`- zipfilelocation = $"{ApplicationSettings.LocalDir}{Path.GetFileNameWithoutExtension(arg)}.zevtc";`
`674`		`- using var zipfile = ZipFile.Open(zipfilelocation, ZipArchiveMode.Create);`
`675`		`- zipfile.CreateEntryFromFile(arg, Path.GetFileName(arg));`
	`674`	`+ zipFileLocation = $"{ApplicationSettings.LocalDir}{Path.GetFileNameWithoutExtension(arg)}.zevtc";`
	`675`	`+ using var zipFile = ZipFile.Open(zipFileLocation, ZipArchiveMode.Create);`
	`676`	`+ zipFile.CreateEntryFromFile(arg, Path.GetFileName(arg));`
`676`	`677`	`archived = true;`
`677`	`678`	`}`
`678`	`679`	`try`
`679`	`680`	`{`
`680`		`- await HttpUploadLogAsync(zipfilelocation, defaultPostData);`
	`681`	`+ await HttpUploadLogAsync(zipFileLocation, defaultPostData);`
`681`	`682`	`}`
`682`	`683`	`catch`
`683`	`684`	`{`
`684`		`- AddToText($">>> Unknown error uploading a log: {zipfilelocation}");`
	`685`	`+ AddToText($">>> Unknown error uploading a log: {zipFileLocation}");`
`685`	`686`	`}`
`686`	`687`	`finally`
`687`	`688`	`{`
`688`	`689`	`if (archived)`
`689`	`690`	`{`
`690`		`- File.Delete(zipfilelocation);`
	`691`	`+ File.Delete(zipFileLocation);`
`691`	`692`	`}`
`692`	`693`	`}`
`693`	`694`	`}`
`694`	`695`	`}`
`695`	`696`	`HandleLogReuploads();`
	`697`	`+ HandleWingmanRePings();`
`696`	`698`	`}`
`697`	`699`
`698`	`700`	`private async Task ValidateGw2Tokens()`
`@@ -787,19 +789,19 @@ private async Task HttpUploadLogAsync(string file, Dictionary<string, string> po`
`787`	`789`	`if (reportJson?.Error?.Contains("EI Failure") ?? false)`
`788`	`790`	`{`
`789`	`791`	`AddToText(">:> Due to an Elite Insights error while processing the log file, it will not be automatically reuploaded. Is the log file corrupted?");`
`790`		`- LogReuploader.RemovedLogAndSave(file);`
	`792`	`+ LogReuploader.RemoveLogAndSave(file);`
`791`	`793`	`return;`
`792`	`794`	`}`
`793`	`795`	`if (reportJson?.Error?.Contains("An identical file was uploaded recently") ?? false)`
`794`	`796`	`{`
`795`	`797`	`AddToText(">:> To prevent same log regeneration, the upload try will not be automatically reuploaded.");`
`796`		`- LogReuploader.RemovedLogAndSave(file);`
	`798`	`+ LogReuploader.RemoveLogAndSave(file);`
`797`	`799`	`return;`
`798`	`800`	`}`
`799`	`801`	`if (reportJson?.Error?.Contains("Encounter is too short") ?? false)`
`800`	`802`	`{`
`801`	`803`	`AddToText(">:> Encounter is too short to generate a valid log, the upload try will not be automatically reuploaded.");`
`802`		`- LogReuploader.RemovedLogAndSave(file);`
	`804`	`+ LogReuploader.RemoveLogAndSave(file);`
`803`	`805`	`return;`
`804`	`806`	`}`
`805`	`807`	`}`
`@@ -827,7 +829,7 @@ private async Task HttpUploadLogAsync(string file, Dictionary<string, string> po`
`827`	`829`	`}`
`828`	`830`	`LogReuploader.FailedLogs.Add(file);`
`829`	`831`	`LogReuploader.SaveFailedLogs();`
`830`		`- EnsureReuploadTimerStart();`
	`832`	`+ EnsureReuploadAndRePingTimerStart();`
`831`	`833`	`return;`
`832`	`834`	`}`
`833`	`835`	`AddToText($">:> Unable to upload file {Path.GetFileName(file)}, dps.report responded with an non-ok status code ({(int)responseMessage.StatusCode}).");`
`@@ -924,7 +926,7 @@ private async Task HttpUploadLogAsync(string file, Dictionary<string, string> po`
`924`	`926`	`// report success`
`925`	`927`	`AddToText($">:> {Path.GetFileName(file)} successfully uploaded.");`
`926`	`928`	`// remove from failed logs if present`
`927`		`- LogReuploader.RemovedLogAndSave(file);`
	`929`	`+ LogReuploader.RemoveLogAndSave(file);`
`928`	`930`	`}`
`929`	`931`	`catch (Exception e)`
`930`	`932`	`{`
`@@ -954,7 +956,7 @@ private async Task HandleQuickLogUploadRetry(string file, Dictionary<string, str`
`954`	`956`	`AddToText($">:> Upload retry failed 4 times for {Path.GetFileName(file)}, will try again during log reupload timer.");`
`955`	`957`	`LogReuploader.FailedLogs.Add(file);`
`956`	`958`	`LogReuploader.SaveFailedLogs();`
`957`		`- EnsureReuploadTimerStart();`
	`959`	`+ EnsureReuploadAndRePingTimerStart();`
`958`	`960`	`}`
`959`	`961`	`else`
`960`	`962`	`{`
`@@ -984,11 +986,7 @@ private async Task ExecuteAllDiscordWebhooks(DpsReportJson reportJson, List<LogP`
`984`	`986`	`{`
`985`	`987`	`if (logSessionLink.SessionRunning)`
`986`	`988`	`{`
`987`		`- if (logSessionLink.checkBoxOnlySuccess.Checked && (reportJson.Encounter.Success ?? false))`
`988`		`- {`
`989`		`- SessionLogs.Add(reportJson);`
`990`		`- }`
`991`		`- else if (!logSessionLink.checkBoxOnlySuccess.Checked)`
	`989`	`+ if ((logSessionLink.checkBoxOnlySuccess.Checked && (reportJson.Encounter.Success ?? false)) \|\| !logSessionLink.checkBoxOnlySuccess.Checked)`
`992`	`990`	`{`
`993`	`991`	`SessionLogs.Add(reportJson);`
`994`	`992`	`}`
`@@ -1045,7 +1043,23 @@ private async Task CrossUploadToWingman(string file, DpsReportJsonExtraJson extr`
`1045`	`1043`	`{`
`1046`	`1044`	`return;`
`1047`	`1045`	`}`
`1048`		`- AddToText(await Gw2WingmanUploader.Upload(file, extraJson));`
	`1046`	`+ var resultText = await Gw2WingmanUploader.Upload(file, extraJson);`
	`1047`	`+ if (resultText.Contains("fail") && !resultText.Contains("exists"))`
	`1048`	`+ {`
	`1049`	`+ WingmanRePing.LogsToPing.Add(new WingmanPingInfo`
	`1050`	`+ {`
	`1051`	`+ FilePath = file,`
	`1052`	`+ TriggerId = extraJson.TriggerId,`
	`1053`	`+ UploadedBy = extraJson.RecordedByAccountName,`
	`1054`	`+ });`
	`1055`	`+ WingmanRePing.SaveLogsToPing();`
	`1056`	`+ EnsureReuploadAndRePingTimerStart();`
	`1057`	`+ }`
	`1058`	`+ else`
	`1059`	`+ {`
	`1060`	`+ WingmanRePing.RemoveLogAndSave(file);`
	`1061`	`+ }`
	`1062`	`+ AddToText(resultText);`
`1049`	`1063`	`}`
`1050`	`1064`
`1051`	`1065`	`internal bool IsTwitchConnectionNull() => chatConnect is null;`
`@@ -1706,18 +1720,19 @@ private void TimerCheckUpdate_Elapsed(object sender, EventArgs e)`
`1706`	`1720`	`_ = NewReleaseCheckAsync(false, true);`
`1707`	`1721`	`}`
`1708`	`1722`
`1709`		`- private void TimerFailedLogsReupload_Elapsed(object sender, EventArgs e)`
	`1723`	`+ private void TimerFailedLogsReuploadAndRePingElapsed(object sender, EventArgs e)`
`1710`	`1724`	`{`
`1711`	`1725`	`HandleLogReuploads();`
	`1726`	`+ HandleWingmanRePings();`
`1712`	`1727`	`}`
`1713`	`1728`
`1714`		`- private void EnsureReuploadTimerStart()`
	`1729`	`+ private void EnsureReuploadAndRePingTimerStart()`
`1715`	`1730`	`{`
`1716`		`- if (timerFailedLogsReupload.Enabled)`
	`1731`	`+ if (timerFailedLogsReuploadAndRePing.Enabled)`
`1717`	`1732`	`{`
`1718`	`1733`	`return;`
`1719`	`1734`	`}`
`1720`		`- timerFailedLogsReupload.Start();`
	`1735`	`+ timerFailedLogsReuploadAndRePing.Start();`
`1721`	`1736`	`}`
`1722`	`1737`
`1723`	`1738`	`private void HandleLogReuploads()`
`@@ -1731,6 +1746,17 @@ private void HandleLogReuploads()`
`1731`	`1746`	`AddToText(">:> Log reuploading has ended.");`
`1732`	`1747`	`}`
`1733`	`1748`
	`1749`	`+ private void HandleWingmanRePings()`
	`1750`	`+ {`
	`1751`	`+ if (WingmanRePing.LogsToPing.Count == 0)`
	`1752`	`+ {`
	`1753`	`+ return;`
	`1754`	`+ }`
	`1755`	`+ AddToText($">:> Starting wingman re-pings of {WingmanRePing.LogsToPing.Count} logs...");`
	`1756`	`+ WingmanRePing.ProcessLogs(semaphore, CrossUploadToWingman);`
	`1757`	`+ AddToText(">:> Wingman re-pings has been completed.");`
	`1758`	`+ }`
	`1759`	`+`
`1734`	`1760`	`private void ComboBoxMaxUploads_SelectedIndexChanged(object sender, EventArgs e)`
`1735`	`1761`	`{`
`1736`	`1762`	`if (!int.TryParse(comboBoxMaxUploads.Text, out var threads))`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@`
`2`	`2`	`using System;`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`	`using System.IO;`
`5`		`-using System.Linq;`
`6`	`5`	`using System.Threading;`
`7`	`6`	`using System.Threading.Tasks;`
`8`	`7`	`using ZLinq;`
`@@ -24,24 +23,28 @@ internal static HashSet<string> FailedLogs`
`24`	`23`	`{`
`25`	`24`	`get`
`26`	`25`	`{`
`27`		`- if (_failedLogs is null)`
	`26`	`+ if (_failedLogs is not null)`
`28`	`27`	`{`
`29`		`- if (File.Exists(FileLocation))`
	`28`	`+ return _failedLogs;`
	`29`	`+ }`
	`30`	`+ if (File.Exists(FileLocation))`
	`31`	`+ {`
	`32`	`+ try`
`30`	`33`	`{`
`31`		`- try`
`32`		`- {`
`33`		`- _failedLogs = File.ReadAllLines(FileLocation).Where(File.Exists).ToHashSet();`
`34`		`- }`
`35`		`- catch`
`36`		`- {`
`37`		`- _failedLogs = [];`
`38`		`- }`
	`34`	`+ _failedLogs = File.ReadAllLines(FileLocation)`
	`35`	`+ .AsValueEnumerable()`
	`36`	`+ .Where(File.Exists)`
	`37`	`+ .ToHashSet();`
`39`	`38`	`}`
`40`		`- else`
	`39`	`+ catch`
`41`	`40`	`{`
`42`	`41`	`_failedLogs = [];`
`43`	`42`	`}`
`44`	`43`	`}`
	`44`	`+ else`
	`45`	`+ {`
	`46`	`+ _failedLogs = [];`
	`47`	`+ }`
`45`	`48`	`return _failedLogs;`
`46`	`49`	`}`
`47`	`50`	`}`
`@@ -58,7 +61,7 @@ internal static void SaveFailedLogs()`
`58`	`61`	`}`
`59`	`62`	`}`
`60`	`63`
`61`		`- internal static bool RemovedLogAndSave(string file)`
	`64`	`+ internal static bool RemoveLogAndSave(string file)`
`62`	`65`	`{`
`63`	`66`	`var removed = FailedLogs.Remove(file);`
`64`	`67`	`if (removed)`
`@@ -70,7 +73,7 @@ internal static bool RemovedLogAndSave(string file)`
`70`	`73`
`71`	`74`	`internal static void ProcessLogs(SemaphoreSlim semaphore, Func<string, Dictionary<string, string>, bool, Task> process)`
`72`	`75`	`{`
`73`		`- foreach (var fileName in FailedLogs.ToArray().AsValueEnumerable())`
	`76`	`+ foreach (var fileName in FailedLogs.AsValueEnumerable())`
`74`	`77`	`{`
`75`	`78`	`if (!File.Exists(fileName))`
`76`	`79`	`{`
`@@ -79,7 +82,7 @@ internal static void ProcessLogs(SemaphoreSlim semaphore, Func<string, Dictionar`
`79`	`82`	`}`
`80`	`83`	`_ = Task.Run(async () =>`
`81`	`84`	`{`
`82`		`- semaphore.Wait();`
	`85`	`+ await semaphore.WaitAsync();`
`83`	`86`	`await process(fileName, PostData, true);`
`84`	`87`	`semaphore.Release();`
`85`	`88`	`});`