Concurrent Downloading actually working

RXPatchLib/DirectoryPatcher.cs

@@ -302,6 +302,52 @@ public InstructionModel(FilePatchInstruction x, long y)
             }
         }
 
+        internal async Task Analyze(CancellationToken cancellationToken, Action<IFilePatchAction> callback, Action<DirectoryPatchPhaseProgress> progressCallback, string instructions_hash)
+        {
+            // Download instructions
+            await PatchSource.Load("instructions.json", instructions_hash, cancellationToken, (done, total) => { });
+
+            // Open downloaded instructions.json and copy its contents to headerFileContents
+            string headerFileContents;
+            using (var file = File.Open(PatchSource.GetSystemPath("instructions.json"), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
+            using (var streamReader = new StreamReader(file, Encoding.UTF8))
+            {
+                headerFileContents = streamReader.ReadToEnd();
+            }
+
+            // Deserialize JSON data from headerFileContents
+            List<FilePatchInstruction> instructions = JsonConvert.DeserializeObject<List<FilePatchInstruction>>(headerFileContents);
+
+            // Initialize progress-related variables
+            var progress = new DirectoryPatchPhaseProgress();
+            var paths = instructions.Select(i => Path.Combine(_targetPath, i.Path));
+            var sizes = paths.Select(p => !File.Exists(p) ? 0 : new FileInfo(p).Length);
+            progress.SetTotals(instructions.Count, sizes.Sum());
+            progress.State = DirectoryPatchPhaseProgress.States.Started;
+            progressCallback(progress);
+
+            // Process each instruction in instructions.json
+            foreach (var pair in instructions.Zip(sizes, (i, s) => new { Instruction = i, Size = s }))
+            {
+                var instruction = pair.Instruction;
+                cancellationToken.ThrowIfCancellationRequested();
+                string targetFilePath = Path.Combine(_targetPath, instruction.Path);
+
+                // Determine action(s) to take based on instruction; any new actions get passed to the callback
+                await BuildFilePatchAction(instruction, targetFilePath, callback);
+
+                // Update progress
+                progress.AdvanceItem(pair.Size);
+                progressCallback(progress);
+            }
+
+            // We're done here; update our State and update progress
+            progress.State = DirectoryPatchPhaseProgress.States.Finished;
+            progressCallback(progress);
+        }
+
+
+        /*
         internal async Task Analyze(CancellationToken cancellationToken, Action<IFilePatchAction> callback, Action<DirectoryPatchPhaseProgress> progressCallback, string instructionsHash)
         {
             // Create our background workers
@@ -390,6 +436,7 @@ internal async Task Analyze(CancellationToken cancellationToken, Action<IFilePat
             progress.State = DirectoryPatchPhaseProgress.States.Finished;
             progressCallback(progress);
         }
+        */
 
         private async Task BuildFilePatchAction(FilePatchInstruction instruction, string targetFilePath, Action<IFilePatchAction> callback)
         {

RXPatchLib/RXPatcher.cs

@@ -25,6 +25,7 @@ public class RxPatcher
         public static RxPatcher Instance => _instance ?? (_instance = new RxPatcher());
 
         public readonly UpdateServerHandler UpdateServerHandler = new UpdateServerHandler();
+        public UpdateServerSelector UpdateServerSelector = new UpdateServerSelector();
 
         public void AddNewUpdateServer(string url, string friendlyName)
         {

RXPatchLib/WebPatchSource.cs

@@ -17,6 +17,7 @@ class WebPatchSource : IPatchSource, IDisposable
         readonly string _downloadPath;
         bool _isDownloading = false;
         readonly object _isDownloadingLock = new object();
+        private byte _downloadsRunning = 0;
 
         public WebPatchSource(RxPatcher patcher, string downloadPath)
         {
@@ -51,21 +52,28 @@ private async Task LockDownload()
             {
                 lock (_isDownloadingLock)
                 {
-                    if (!_isDownloading)
+                    //if (!_isDownloading)
+                    if (_downloadsRunning < 8)
                     {
                         _isDownloading = true;
+                        _downloadsRunning++;
+                        Debug.Print($"{Thread.CurrentThread.ManagedThreadId} | DLRUN: {_downloadsRunning} | ACCEPTING DOWNLOAD");
                         break;
                     }
                 }
 
-                await Task.Delay(100);
+                await Task.Delay(1000);
             }
         }
 
         private void UnlockDownload()
         {
             lock (_isDownloadingLock)
+            {
+                _downloadsRunning--;
+                Debug.Print($"{Thread.CurrentThread.ManagedThreadId} | DLRUN: {_downloadsRunning} | DOWNLOAD COMPLETE");
                 _isDownloading = false;
+            }
         }
 
         public async Task LoadNew(string subPath, string hash, CancellationToken cancellationToken, Action<long, long> progressCallback)
@@ -116,11 +124,19 @@ await retryStrategy.Run(async () =>
                         {
                             try
                             {
-                                var thisPatchServer = _patcher.UpdateServerHandler.SelectBestPatchServer();
+                                var rnd = new Random();
+                                var xyz = _patcher.UpdateServerSelector.Hosts.ToArray();
+                                var thisPatchServer = xyz[rnd.Next(0, 3)];
+                                if (thisPatchServer == null)
+                                    throw new Exception("Unable to find a better update server");
+
+                                thisPatchServer.IsUsed = true;
+
                                 // Download file and wait until finished
                                 RxLogger.Logger.Instance.Write($"Starting file transfer: {_patcher.UpdateServer.Uri.AbsoluteUri}/{_patcher.WebPatchPath}/{subPath}");
                                 await webClient.DownloadFileTaskAsync(new Uri($"{_patcher.UpdateServer.Uri.AbsoluteUri}/{_patcher.WebPatchPath}/{subPath}"), filePath);
                                 RxLogger.Logger.Instance.Write("  > File Transfer Complete");
+
                                 thisPatchServer.IsUsed = false;
 
                                 // File finished downoading successfully; allow next download to start and check hash

Renegade X Launcher/Views/ApplyUpdateWindow.xaml.cs

@@ -34,6 +34,7 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
         {
             if (!(value is DirectoryPatchPhaseProgress)) return DependencyProperty.UnsetValue;
             var progress = (DirectoryPatchPhaseProgress)value;
+            //RxLogger.Logger.Instance.Write($"PhaseProgressPercentageConverter -> Value = {progress.Items.Done} / {progress.Items.Total} | {progress.State}");
             if (progress.State == DirectoryPatchPhaseProgress.States.Unstarted)
                 return 0;
             else if (progress.State == DirectoryPatchPhaseProgress.States.Indeterminate)
@@ -60,6 +61,8 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
             var progress = value as DirectoryPatchPhaseProgress;
             if (progress == null)
                 return "unknown";
+
+            //RxLogger.Logger.Instance.Write($"PhaseProgressPercentageConverter -> Value = {progress.Items.Done} / {progress.Items.Total} | {progress.State}");
             if (progress.State == DirectoryPatchPhaseProgress.States.Unstarted)
                 return "not started";
             else if (progress.State == DirectoryPatchPhaseProgress.States.Finished)