using System.Net;
using System.Net.Http.Headers;
namespace Triforce.Logic;
/// How far a download is: 0..1 (0 while the size is unknown), the bytes there, the whole size (0 unknown).
public readonly record struct DownloadProgress(double Fraction, long Bytes, long Total);
/// A file fetched over HTTP into place through <file>.part, and checked before it is used (old Guard.cs Download).
///
/// A download that was cut off (the connection, Cancel, the launcher closed) leaves its part file, and the next one goes on from
/// it with a Range request where the server answers those; a server that does not sends the whole file, and the part is written
/// over. A part is gone on from only as a part of the same file: <file>.part.of beside it names the address and the size it
/// was begun for and the server's mark for the file it sent (its ETag, else its date), which goes back with the request
/// (If-Range), so a file published again under the same address comes whole and is never joined to the beginning of the one
/// before. A part without that note, or from a server that marks its files in neither way, is fetched anew.
///
/// The file gets its name only once it has the size the release lists (else the one the server names), and a server that names
/// another size than the release's is not believed before its first byte.
public sealed class Downloader
{
readonly TriforceContext ctx;
public Downloader(TriforceContext ctx) { this.ctx = ctx; }
/// How long the server may send nothing before the download is given up (its part stays to be gone on from). A read
/// that waits on the network hears no cancellation: it is left waiting and its connection closed behind it, for Cancel too.
public TimeSpan Stall { get; set; } = TimeSpan.FromSeconds(60);
static void Remove(string file)
{
try { File.Delete(file); } catch (Exception) { }
}
static string Mb(long bytes) => (bytes >> 20).ToString();
/// The server's mark for the file it sends, to hand back with If-Range: a strong ETag, else the date it was last changed.
static string Mark(HttpResponseMessage response) =>
response.Headers.ETag is { IsWeak: false } tag ? tag.ToString()
: response.Content.Headers.LastModified is { } changed ? changed.UtcDateTime.ToString("r") : "";
/// url to file, with progress. size is what the release lists for it, 0 when it lists none.
public async Task ToFileAsync(HttpClient http, string url, string file, long size, Action? progress, CancellationToken token)
{
var name = Path.GetFileName(file);
var part = file + ".part";
var note = part + ".of";
long have = 0;
RangeConditionHeaderValue? same = null;
void Forget() { Remove(part); Remove(note); }
void Say(double f, long b, long t) => progress?.Invoke(new DownloadProgress(f, b, t));
Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(file))!);
if (File.Exists(part))
{
// (what the part is a part of: only the same address, size and mark are gone on from, and never a part as long as the file)
string[] of = { };
try { of = File.ReadAllLines(note); } catch (Exception) { }
var length = new FileInfo(part).Length;
if (of.Length >= 3 && of[0] == url && of[1] == size.ToString() && RangeConditionHeaderValue.TryParse(of[2], out same) && length > 0 && (size <= 0 || length < size))
have = length;
else Forget();
}
using var stall = new CancellationTokenSource();
using var either = CancellationTokenSource.CreateLinkedTokenSource(token, stall.Token);
for (var again = false; ; again = true)
{
using var request = new HttpRequestMessage(HttpMethod.Get, url);
if (have > 0)
{
request.Headers.Range = new RangeHeaderValue(have, null);
request.Headers.IfRange = same;
}
stall.CancelAfter(Stall);
HttpResponseMessage response;
try { response = await http.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, either.Token).ConfigureAwait(false); }
catch (OperationCanceledException) when (!token.IsCancellationRequested && stall.IsCancellationRequested)
{
throw new CutOffException("The server did not answer for " + (int)Stall.TotalSeconds + " seconds about " + name + ". Try again.");
}
var left = false; // (the answer was left with a read still waiting on it)
try
{
var range = response.StatusCode == HttpStatusCode.PartialContent ? response.Content.Headers.ContentRange : null;
// (416: the part is no part of what the server has now. A range other than the one asked for: not to be joined on.
// Either way the whole file is asked for, once)
if (have > 0 && !again && (response.StatusCode == HttpStatusCode.RequestedRangeNotSatisfiable ||
response.StatusCode == HttpStatusCode.PartialContent && !(range is { HasRange: true } && range.From == have)))
{
Forget();
have = 0;
continue;
}
response.EnsureSuccessStatusCode();
if (response.StatusCode == HttpStatusCode.PartialContent && (have == 0 || !(range is { HasRange: true } && range.From == have)))
throw new IOException("The server sent a piece of " + name + " that was not asked for.");
// (200 to a request for the rest: the server knows no ranges, or the file is another one now. The whole file comes)
if (response.StatusCode != HttpStatusCode.PartialContent) have = 0;
// the whole file's size: the release's, which the server must not contradict; else the server's
var told = have > 0 ? range!.Length ?? have + response.Content.Headers.ContentLength : response.Content.Headers.ContentLength;
if (size > 0 && told is { } other && other != size)
{
Forget();
throw new IOException("The server offers " + other + " bytes as " + name + ", and the release lists " + size + ". Nothing was downloaded.");
}
var total = size > 0 ? size : told ?? 0;
if (total > 0 && ctx.SpaceProblem(name, total - have, file) is { } none) throw new NoRoomException(none);
if (have == 0)
{
Remove(part);
try { File.WriteAllLines(note, new[] { url, size.ToString(), Mark(response) }); } catch (Exception) { }
}
Say(total > 0 ? Math.Min(1.0, (double)have / total) : 0, have, total);
var from = await response.Content.ReadAsStreamAsync(either.Token).ConfigureAwait(false);
var gone = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
var tooMuch = false;
using (var to = new FileStream(part, have > 0 ? FileMode.Append : FileMode.Create, FileAccess.Write, FileShare.None))
using (either.Token.Register(() => gone.TrySetResult(true)))
{
var buffer = new byte[1 << 20];
var shown = DateTime.MinValue;
try
{
for (;;)
{
stall.CancelAfter(Stall);
var read = from.ReadAsync(buffer, 0, buffer.Length, either.Token);
if (await Task.WhenAny(read, gone.Task).ConfigureAwait(false) != read)
{
// (Cancel, or nothing came: the read is left where it waits, whatever becomes of it)
left = true;
_ = read.ContinueWith(t => t.Exception, TaskContinuationOptions.OnlyOnFaulted);
throw new OperationCanceledException();
}
var n = await read.ConfigureAwait(false);
stall.CancelAfter(Timeout.InfiniteTimeSpan);
if (n <= 0) break;
await to.WriteAsync(buffer.AsMemory(0, n), CancellationToken.None).ConfigureAwait(false);
have += n;
// (a server that sends more than the file would fill the disk)
if (total > 0 && have > total) { tooMuch = true; break; }
if (DateTime.UtcNow - shown > TimeSpan.FromMilliseconds(150))
{
shown = DateTime.UtcNow;
Say(total > 0 ? Math.Min(1.0, (double)have / total) : 0, have, total);
}
}
}
catch (Exception e)
{
if (token.IsCancellationRequested) throw new OperationCanceledException(token);
var of = total > 0 ? " of " + Mb(total) : "";
if (stall.IsCancellationRequested)
throw new CutOffException("The download of " + name + " stopped after " + Mb(have) + of + " MB: nothing more came for " + (int)Stall.TotalSeconds +
" seconds. Try again: it goes on from there.");
if (ctx.Platform.IsDiskFull(e)) throw;
throw new CutOffException("The download of " + name + " was cut off after " + Mb(have) + of + " MB. Try again: it goes on from there.", e);
}
}
if (tooMuch)
{
Forget();
throw new IOException("The server sent more than the " + total + " bytes of " + name + ". Nothing of it was kept.");
}
if (total > 0 && have < total)
throw new CutOffException("The download of " + name + " ended early, after " + Mb(have) + " of " + Mb(total) + " MB. Try again: it goes on from there.");
break;
}
finally
{
// (closing an answer can wait for the network as its read did: one that was left is closed where nobody waits for that)
if (left) _ = Task.Run(() => { try { response.Dispose(); } catch (Exception) { } });
else response.Dispose();
}
}
// (before it is used: what is on the disk is what was counted)
var there = new FileInfo(part).Length;
if (there != have)
{
Forget();
throw new IOException(name + " is " + there + " bytes on the disk where " + have + " were downloaded. Nothing of it was kept.");
}
if (File.Exists(file)) File.Delete(file);
File.Move(part, file);
Remove(note);
Say(1, have, have);
}
/// The HttpClient every release request goes through: no overall timeout (a 300 MB download takes what it takes; the
/// release check has its own 20 s), the launcher's User-Agent (old Shell.cs Http).
public static HttpClient CreateHttp()
{
var http = new HttpClient { Timeout = Timeout.InfiniteTimeSpan };
http.DefaultRequestHeaders.UserAgent.ParseAdd(BuildInfo.UserAgent);
return http;
}
}