feat: add speed limits

Configuration.cs

@@ -25,6 +25,12 @@ internal class Configuration : IPluginConfiguration {
     public byte[]? OneClickSalt;
     public string? OneClickHash;
     public string? OneClickCollection;
+    public long MaxKibsPerSecond;
+    public long AltMaxKibsPerSecond;
+    public SpeedLimit LimitNormal = SpeedLimit.On;
+    public SpeedLimit LimitInstance = SpeedLimit.Default;
+    public SpeedLimit LimitCombat = SpeedLimit.Default;
+    public SpeedLimit LimitParty = SpeedLimit.Default;
 
     public Configuration() {
     }
@@ -44,6 +50,12 @@ internal Configuration(Configuration other) {
         this.OneClickSalt = other.OneClickSalt;
         this.OneClickHash = other.OneClickHash;
         this.OneClickCollection = other.OneClickCollection;
+        this.MaxKibsPerSecond = other.MaxKibsPerSecond;
+        this.AltMaxKibsPerSecond = other.AltMaxKibsPerSecond;
+        this.LimitNormal = other.LimitNormal;
+        this.LimitInstance = other.LimitInstance;
+        this.LimitCombat = other.LimitCombat;
+        this.LimitParty = other.LimitParty;
     }
 
     private void Redact() {
@@ -62,4 +74,10 @@ internal static Configuration CloneAndRedact(Configuration other) {
 
         return redacted;
     }
+
+    internal enum SpeedLimit {
+        Default,
+        On,
+        Alternate,
+    }
 }

DownloadTask.cs

@@ -1,7 +1,9 @@
+using System.Diagnostics;
 using System.Net.Http.Headers;
 using System.Text;
 using Blake3;
 using Dalamud.Interface.Internal.Notifications;
+using DequeNet;
 using gfoidl.Base64;
 using Heliosphere.Exceptions;
 using Heliosphere.Model;
@@ -44,6 +46,33 @@ internal class DownloadTask : IDisposable {
     internal uint StateData { get; private set; }
     internal uint StateDataMax { get; private set; }
     internal Exception? Error { get; private set; }
+    private ConcurrentDeque<Measurement> Entries { get; } = new();
+
+    private const double Window = 5;
+    internal double BytesPerSecond {
+        get {
+            if (this.Entries.Count == 0) {
+                return 0;
+            }
+
+            var total = 0u;
+            var removeTo = 0;
+            foreach (var entry in this.Entries) {
+                if (Stopwatch.GetElapsedTime(entry.Ticks) > TimeSpan.FromSeconds(Window)) {
+                    removeTo += 1;
+                    continue;
+                }
+
+                total += entry.Data;
+            }
+
+            for (var i = 0; i < removeTo; i++) {
+                this.Entries.TryPopLeft(out _);
+            }
+
+            return total / Window;
+        }
+    }
 
     private bool _disposed;
     private string? _oldModName;
@@ -461,7 +490,10 @@ StateCounter counter
             var chunk = chunks[i];
 
             // get the content of this multipart chunk as a stream
-            await using var stream = await content.ReadAsStreamAsync(this.CancellationToken.Token);
+            await using var stream = new GloballyThrottledStream(
+                await content.ReadAsStreamAsync(this.CancellationToken.Token),
+                this.Entries
+            );
 
             // now we're going to read each file in the chunk out,
             // decompress it, and write it to the disk
@@ -662,7 +694,10 @@ await Retry(3, $"Error downloading {baseUri}/{hash}", async _ => {
             resp.EnsureSuccessStatusCode();
 
             await using var file = File.Create(path);
-            await using var stream = await resp.Content.ReadAsStreamAsync(this.CancellationToken.Token);
+            await using var stream = new GloballyThrottledStream(
+                await resp.Content.ReadAsStreamAsync(this.CancellationToken.Token),
+                this.Entries
+            );
             await new DecompressionStream(stream).CopyToAsync(file, this.CancellationToken.Token);
 
             return false;
@@ -1190,6 +1225,11 @@ internal DownloadOptions(Dictionary<string, List<string>> options) {
     private struct FullDownloadOptions {
         public bool Full;
     }
+
+    internal struct Measurement {
+        internal long Ticks;
+        internal uint Data;
+    }
 }
 
 internal enum State {
@@ -1293,4 +1333,4 @@ public override long Position {
         get => this._inner.Position;
         set => this._inner.Position = value;
     }
-}
+}

Plugin.cs

@@ -2,6 +2,7 @@
 using System.Net.Http.Headers;
 using System.Text.Json;
 using System.Text.RegularExpressions;
+using Dalamud.Game.ClientState.Conditions;
 using Dalamud.Interface.Internal;
 using Dalamud.Interface.Internal.Notifications;
 using Dalamud.IoC;
@@ -51,11 +52,17 @@ public class Plugin : IDalamudPlugin {
     [PluginService]
     internal ICommandManager CommandManager { get; init; }
 
+    [PluginService]
+    internal ICondition Condition { get; init; }
+
+    [PluginService]
+    internal IDutyState DutyState { get; init; }
+
     [PluginService]
     internal IFramework Framework { get; init; }
 
     [PluginService]
-    private IPluginLog PluginLog { get; init; }
+    internal IPartyList PartyList { get; init; }
 
     internal Configuration Config { get; }
     internal DownloadCodes DownloadCodes { get; }
@@ -85,7 +92,6 @@ public Plugin() {
         Instance = this;
         GameFont = new GameFont(this);
         PluginInterface = this.Interface!;
-        Log = this.PluginLog!;
 
         this.Sentry = SentrySdk.Init(o => {
             o.Dsn = "https://[email protected]/4";
@@ -167,6 +173,8 @@ public Plugin() {
         this.LinkPayloads = new LinkPayloads(this);
         this.CommandHandler = new CommandHandler(this);
 
+        this.Framework!.Update += this.CalculateSpeedLimit;
+
         if (startWithAvWarning || checkTask is { Status: TaskStatus.RanToCompletion, Result: true }) {
             this.PluginUi.OpenAntiVirusWarning();
         }
@@ -175,6 +183,7 @@ public Plugin() {
     }
 
     public void Dispose() {
+        this.Framework.Update -= this.CalculateSpeedLimit;
         this.CommandHandler.Dispose();
         this.LinkPayloads.Dispose();
         this.Server.Dispose();
@@ -186,6 +195,7 @@ public void Dispose() {
         GameFont.Dispose();
         ImageLoadSemaphore.Dispose();
         DownloadSemaphore.Dispose();
+        GloballyThrottledStream.Shutdown();
 
         foreach (var wrap in this.CoverImages.Deconstruct().Values) {
             wrap.Dispose();
@@ -196,6 +206,46 @@ internal void SaveConfig() {
         this.Interface.SavePluginConfig(this.Config);
     }
 
+    private void CalculateSpeedLimit(IFramework framework) {
+        var limit = this.CalculateLimit();
+        GloballyThrottledStream.MaxBytesPerSecond = limit switch {
+            Configuration.SpeedLimit.On => this.Config.MaxKibsPerSecond * 1_024,
+            Configuration.SpeedLimit.Alternate => this.Config.AltMaxKibsPerSecond * 1_024,
+            Configuration.SpeedLimit.Default => this.Config.LimitNormal switch {
+                Configuration.SpeedLimit.On => this.Config.MaxKibsPerSecond * 1_024,
+                Configuration.SpeedLimit.Default => this.Config.MaxKibsPerSecond * 1_024,
+                Configuration.SpeedLimit.Alternate => this.Config.AltMaxKibsPerSecond * 1_024,
+                _ => 0,
+            },
+            _ => 0,
+        };
+    }
+
+    private Configuration.SpeedLimit CalculateLimit() {
+        if (this.Condition[ConditionFlag.InCombat]) {
+            return this.Config.LimitCombat;
+        }
+
+        if (this.DutyState.IsDutyStarted) {
+            return this.Config.LimitInstance;
+        }
+
+        // if (this.Condition.Any(
+        //         ConditionFlag.BoundByDuty,
+        //         ConditionFlag.BoundByDuty56,
+        //         ConditionFlag.BoundByDuty95,
+        //         ConditionFlag.BoundToDuty97
+        //     )) {
+        //     return this.Config.LimitInstance;
+        // }
+
+        if (this.PartyList.Length > 0) {
+            return this.Config.LimitParty;
+        }
+
+        return this.Config.LimitNormal;
+    }
+
     internal async Task AddDownloadAsync(DownloadTask task, CancellationToken token = default) {
         bool wasAdded;
         using (var guard = await this.Downloads.WaitAsync(token)) {

Ui/DownloadStatusWindow.cs

@@ -77,6 +77,14 @@ private void DrawRealDownloads(Guard<List<DownloadTask>>.Handle guard) {
                 continue;
             }
 
+            var bps = task.BytesPerSecond;
+            var speed = bps switch {
+                >= 1_073_741_824 => $"{bps / 1_073_741_824:N2} GiB/s",
+                >= 1_048_576 => $"{bps / 1_048_576:N2} MiB/s",
+                >= 1_024 => $"{bps / 1_024:N2} KiB/s",
+                _ => $"{bps:N2} B/s",
+            };
+
             var packageName = task switch {
                 { PackageName: not null, VariantName: null } => $"{task.PackageName} - ",
                 { PackageName: not null, VariantName: not null } => $"{task.PackageName} ({task.VariantName}) - ",
@@ -85,7 +93,7 @@ private void DrawRealDownloads(Guard<List<DownloadTask>>.Handle guard) {
             ImGui.ProgressBar(
                 (float) task.StateData / task.StateDataMax,
                 new Vector2(ImGui.GetContentRegionAvail().X, 25 * ImGuiHelpers.GlobalScale),
-                $"{packageName}{task.State.Name()}: {task.StateData:N0} / {task.StateDataMax:N0}"
+                $"{packageName}{task.State.Name()}: {task.StateData:N0} / {task.StateDataMax:N0} ({speed})"
             );
 
             ImGuiHelper.Tooltip("Hold Ctrl and click to cancel.");

Ui/Tabs/Settings.cs

@@ -61,6 +61,41 @@ internal void Draw() {
             ref this.Plugin.Config.DefaultCollection
         );
 
+        if (ImGui.CollapsingHeader("Download speed limits")) {
+            anyChanged |= ImGuiHelper.InputLongVertical(
+                "Max download speed in KiBs (0 for unlimited)",
+                "##max-download-speed",
+                ref this.Plugin.Config.MaxKibsPerSecond
+            );
+
+            anyChanged |= ImGuiHelper.InputLongVertical(
+                "Alternate download speed in KiBs (0 for unlimited)",
+                "##max-download-speed",
+                ref this.Plugin.Config.AltMaxKibsPerSecond
+            );
+
+            void DrawLimitCombo(string title, string id, ref Configuration.SpeedLimit limit) {
+                ImGui.TextUnformatted(title);
+                if (!ImGui.BeginCombo(id, Enum.GetName(limit))) {
+                    return;
+                }
+
+                foreach (var option in Enum.GetValues<Configuration.SpeedLimit>()) {
+                    if (ImGui.Selectable(Enum.GetName(option), option == limit)) {
+                        limit = option;
+                        anyChanged = true;
+                    }
+                }
+
+                ImGui.EndCombo();
+            }
+
+            DrawLimitCombo("Speed limit (default)", "##speed-limit-normal", ref this.Plugin.Config.LimitNormal);
+            DrawLimitCombo("Speed limit (in instance)", "##speed-limit-instance", ref this.Plugin.Config.LimitInstance);
+            DrawLimitCombo("Speed limit (in combat)", "##speed-limit-combat", ref this.Plugin.Config.LimitCombat);
+            DrawLimitCombo("Speed limit (in party)", "##speed-limit-party", ref this.Plugin.Config.LimitParty);
+        }
+
         if (ImGui.CollapsingHeader("One-click install")) {
             anyChanged |= ImGui.Checkbox("Enable", ref this.Plugin.Config.OneClick);