mirror of
https://github.com/wwiinnddyy/LanMountainDesktop.git
synced 2026-06-20 23:54:26 +08:00
644 lines
26 KiB
C#
644 lines
26 KiB
C#
using System.Globalization;
|
|
using System.Net;
|
|
using System.Net.Http.Headers;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Xml.Linq;
|
|
|
|
namespace Plonds.Core.Publishing;
|
|
|
|
public sealed class PlondsS3Client : IDisposable
|
|
{
|
|
private const string ServiceName = "s3";
|
|
private const string EmptyPayloadHash = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
|
|
|
|
private readonly PlondsS3ClientOptions options;
|
|
private readonly HttpClient httpClient;
|
|
private readonly bool ownsHttpClient;
|
|
|
|
public PlondsS3Client(PlondsS3ClientOptions options, HttpClient? httpClient = null)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(options);
|
|
|
|
this.options = options with
|
|
{
|
|
Endpoint = NormalizeEndpoint(options.Endpoint),
|
|
Region = Require(options.Region, nameof(options.Region)),
|
|
Bucket = Require(options.Bucket, nameof(options.Bucket)),
|
|
AccessKey = Require(options.AccessKey, nameof(options.AccessKey)),
|
|
SecretKey = Require(options.SecretKey, nameof(options.SecretKey)),
|
|
PublicBaseUrl = Require(options.PublicBaseUrl, nameof(options.PublicBaseUrl)).TrimEnd('/'),
|
|
PublicBaseKeyPrefix = NormalizeOptionalKeyPrefix(options.PublicBaseKeyPrefix),
|
|
RequestTimeout = options.RequestTimeout <= TimeSpan.Zero ? TimeSpan.FromMinutes(30) : options.RequestTimeout,
|
|
MaxUploadAttempts = Math.Max(1, options.MaxUploadAttempts),
|
|
MultipartThresholdBytes = Math.Max(5L * 1024 * 1024, options.MultipartThresholdBytes),
|
|
MultipartPartSizeBytes = Math.Max(5L * 1024 * 1024, options.MultipartPartSizeBytes),
|
|
MultipartConcurrency = Math.Max(1, options.MultipartConcurrency)
|
|
};
|
|
|
|
ownsHttpClient = httpClient is null;
|
|
this.httpClient = httpClient ?? new HttpClient
|
|
{
|
|
Timeout = this.options.RequestTimeout
|
|
};
|
|
}
|
|
|
|
public async Task UploadFileAsync(PlondsS3ObjectUpload upload, CancellationToken cancellationToken = default)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(upload);
|
|
|
|
var sourcePath = Path.GetFullPath(upload.SourcePath);
|
|
if (!File.Exists(sourcePath))
|
|
{
|
|
throw new FileNotFoundException("S3 upload source file not found.", sourcePath);
|
|
}
|
|
|
|
var key = NormalizeKey(upload.Key);
|
|
var payloadHash = PayloadUtilities.ComputeSha256(sourcePath);
|
|
var contentLength = new FileInfo(sourcePath).Length;
|
|
|
|
if (contentLength >= options.MultipartThresholdBytes)
|
|
{
|
|
try
|
|
{
|
|
await UploadFileMultipartAsync(sourcePath, key, upload.ContentType, contentLength, cancellationToken).ConfigureAwait(false);
|
|
return;
|
|
}
|
|
catch (Exception ex) when (ex is not OperationCanceledException)
|
|
{
|
|
Console.Error.WriteLine($"S3 multipart upload failed for {key}; falling back to single PUT. {ex.Message}");
|
|
}
|
|
}
|
|
|
|
for (var attempt = 1; attempt <= options.MaxUploadAttempts; attempt++)
|
|
{
|
|
try
|
|
{
|
|
await UploadFileOnceAsync(sourcePath, key, upload.ContentType, payloadHash, contentLength, attempt, cancellationToken).ConfigureAwait(false);
|
|
return;
|
|
}
|
|
catch (Exception ex) when (attempt < options.MaxUploadAttempts && IsRetriable(ex))
|
|
{
|
|
var delay = TimeSpan.FromSeconds(Math.Min(30, Math.Pow(2, attempt)));
|
|
Console.Error.WriteLine($"S3 upload retry {attempt + 1}/{options.MaxUploadAttempts} for {key} after {delay.TotalSeconds:0}s: {ex.Message}");
|
|
await Task.Delay(delay, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async Task UploadFileMultipartAsync(
|
|
string sourcePath,
|
|
string key,
|
|
string? contentType,
|
|
long contentLength,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var uploadId = await CreateMultipartUploadAsync(key, contentType, cancellationToken).ConfigureAwait(false);
|
|
var partCount = checked((int)((contentLength + options.MultipartPartSizeBytes - 1) / options.MultipartPartSizeBytes));
|
|
var parts = new PlondsS3UploadedPart[partCount];
|
|
|
|
Console.WriteLine($"Uploading S3 object {key} ({FormatBytes(contentLength)}) using multipart upload {uploadId}: {partCount} parts, part size {FormatBytes(options.MultipartPartSizeBytes)}, concurrency {options.MultipartConcurrency}.");
|
|
|
|
try
|
|
{
|
|
var completed = 0;
|
|
await Parallel.ForEachAsync(
|
|
Enumerable.Range(1, partCount),
|
|
new ParallelOptions
|
|
{
|
|
MaxDegreeOfParallelism = options.MultipartConcurrency,
|
|
CancellationToken = cancellationToken
|
|
},
|
|
async (partNumber, token) =>
|
|
{
|
|
var offset = (long)(partNumber - 1) * options.MultipartPartSizeBytes;
|
|
var length = Math.Min(options.MultipartPartSizeBytes, contentLength - offset);
|
|
parts[partNumber - 1] = await UploadMultipartPartWithRetriesAsync(
|
|
sourcePath,
|
|
key,
|
|
uploadId,
|
|
partNumber,
|
|
offset,
|
|
length,
|
|
token).ConfigureAwait(false);
|
|
|
|
var done = Interlocked.Increment(ref completed);
|
|
Console.WriteLine($"S3 multipart progress {key}: {done}/{partCount} parts uploaded.");
|
|
}).ConfigureAwait(false);
|
|
|
|
await CompleteMultipartUploadAsync(key, uploadId, parts, cancellationToken).ConfigureAwait(false);
|
|
Console.WriteLine($"Uploaded S3 object {key} using multipart upload.");
|
|
}
|
|
catch
|
|
{
|
|
await AbortMultipartUploadBestEffortAsync(key, uploadId, CancellationToken.None).ConfigureAwait(false);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
private async Task<string> CreateMultipartUploadAsync(string key, string? contentType, CancellationToken cancellationToken)
|
|
{
|
|
var requestUri = BuildObjectUri(key, "uploads=");
|
|
using var request = new HttpRequestMessage(HttpMethod.Post, requestUri);
|
|
if (!string.IsNullOrWhiteSpace(contentType))
|
|
{
|
|
request.Headers.TryAddWithoutValidation("Content-Type", contentType);
|
|
}
|
|
|
|
SignRequest(request, key, EmptyPayloadHash, DateTimeOffset.UtcNow);
|
|
|
|
using var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
|
|
var body = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
throw new InvalidOperationException($"S3 create multipart upload failed for {key}: HTTP {(int)response.StatusCode} {response.ReasonPhrase}. {Truncate(body, 512)}");
|
|
}
|
|
|
|
var uploadId = XDocument.Parse(body).Descendants().FirstOrDefault(element => element.Name.LocalName == "UploadId")?.Value;
|
|
return string.IsNullOrWhiteSpace(uploadId)
|
|
? throw new InvalidOperationException($"S3 create multipart upload response did not include UploadId for {key}.")
|
|
: uploadId;
|
|
}
|
|
|
|
private async Task<PlondsS3UploadedPart> UploadMultipartPartWithRetriesAsync(
|
|
string sourcePath,
|
|
string key,
|
|
string uploadId,
|
|
int partNumber,
|
|
long offset,
|
|
long length,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
for (var attempt = 1; attempt <= options.MaxUploadAttempts; attempt++)
|
|
{
|
|
try
|
|
{
|
|
return await UploadMultipartPartOnceAsync(
|
|
sourcePath,
|
|
key,
|
|
uploadId,
|
|
partNumber,
|
|
offset,
|
|
length,
|
|
attempt,
|
|
cancellationToken).ConfigureAwait(false);
|
|
}
|
|
catch (Exception ex) when (attempt < options.MaxUploadAttempts && IsRetriable(ex))
|
|
{
|
|
var delay = TimeSpan.FromSeconds(Math.Min(30, Math.Pow(2, attempt)));
|
|
Console.Error.WriteLine($"S3 multipart retry {attempt + 1}/{options.MaxUploadAttempts} for {key} part {partNumber} after {delay.TotalSeconds:0}s: {ex.Message}");
|
|
await Task.Delay(delay, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
throw new InvalidOperationException($"S3 multipart upload failed for {key} part {partNumber}.");
|
|
}
|
|
|
|
private async Task<PlondsS3UploadedPart> UploadMultipartPartOnceAsync(
|
|
string sourcePath,
|
|
string key,
|
|
string uploadId,
|
|
int partNumber,
|
|
long offset,
|
|
long length,
|
|
int attempt,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var requestUri = BuildObjectUri(key, $"partNumber={partNumber}&uploadId={Uri.EscapeDataString(uploadId)}");
|
|
var bytes = new byte[length];
|
|
await using (var fileStream = File.OpenRead(sourcePath))
|
|
{
|
|
fileStream.Seek(offset, SeekOrigin.Begin);
|
|
var totalRead = 0;
|
|
while (totalRead < bytes.Length)
|
|
{
|
|
var read = await fileStream.ReadAsync(bytes.AsMemory(totalRead), cancellationToken).ConfigureAwait(false);
|
|
if (read == 0)
|
|
{
|
|
throw new EndOfStreamException($"Unexpected end of file while reading {sourcePath} for part {partNumber}.");
|
|
}
|
|
|
|
totalRead += read;
|
|
}
|
|
}
|
|
|
|
var payloadHash = Sha256Hex(bytes);
|
|
Console.WriteLine($"Uploading S3 multipart part {partNumber} for {key} ({FormatBytes(length)}), attempt {attempt}/{options.MaxUploadAttempts}.");
|
|
|
|
using var content = new ByteArrayContent(bytes);
|
|
content.Headers.ContentLength = length;
|
|
using var request = new HttpRequestMessage(HttpMethod.Put, requestUri)
|
|
{
|
|
Content = content
|
|
};
|
|
SignRequest(request, key, payloadHash, DateTimeOffset.UtcNow);
|
|
|
|
using var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
var body = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
|
|
throw new InvalidOperationException($"S3 multipart upload failed for {key} part {partNumber}: HTTP {(int)response.StatusCode} {response.ReasonPhrase}. {Truncate(body, 512)}");
|
|
}
|
|
|
|
var etag = response.Headers.ETag?.Tag;
|
|
if (string.IsNullOrWhiteSpace(etag))
|
|
{
|
|
throw new InvalidOperationException($"S3 multipart upload did not return ETag for {key} part {partNumber}.");
|
|
}
|
|
|
|
return new PlondsS3UploadedPart(partNumber, etag);
|
|
}
|
|
|
|
private async Task CompleteMultipartUploadAsync(
|
|
string key,
|
|
string uploadId,
|
|
IReadOnlyList<PlondsS3UploadedPart> parts,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var body = BuildCompleteMultipartUploadBody(parts);
|
|
var bodyBytes = Encoding.UTF8.GetBytes(body);
|
|
var payloadHash = Sha256Hex(bodyBytes);
|
|
var requestUri = BuildObjectUri(key, $"uploadId={Uri.EscapeDataString(uploadId)}");
|
|
|
|
using var content = new ByteArrayContent(bodyBytes);
|
|
content.Headers.ContentType = new MediaTypeHeaderValue("application/xml");
|
|
content.Headers.ContentLength = bodyBytes.Length;
|
|
using var request = new HttpRequestMessage(HttpMethod.Post, requestUri)
|
|
{
|
|
Content = content
|
|
};
|
|
SignRequest(request, key, payloadHash, DateTimeOffset.UtcNow);
|
|
|
|
using var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
var responseBody = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
|
|
throw new InvalidOperationException($"S3 complete multipart upload failed for {key}: HTTP {(int)response.StatusCode} {response.ReasonPhrase}. {Truncate(responseBody, 512)}");
|
|
}
|
|
}
|
|
|
|
private async Task AbortMultipartUploadBestEffortAsync(string key, string uploadId, CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
var requestUri = BuildObjectUri(key, $"uploadId={Uri.EscapeDataString(uploadId)}");
|
|
using var request = new HttpRequestMessage(HttpMethod.Delete, requestUri);
|
|
SignRequest(request, key, EmptyPayloadHash, DateTimeOffset.UtcNow);
|
|
using var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
Console.Error.WriteLine($"S3 abort multipart upload failed for {key}: HTTP {(int)response.StatusCode} {response.ReasonPhrase}.");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.Error.WriteLine($"S3 abort multipart upload failed for {key}: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
public async Task<bool> UploadFileIfChangedAsync(PlondsS3ObjectUpload upload, CancellationToken cancellationToken = default)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(upload);
|
|
|
|
var sourcePath = Path.GetFullPath(upload.SourcePath);
|
|
if (!File.Exists(sourcePath))
|
|
{
|
|
throw new FileNotFoundException("S3 upload source file not found.", sourcePath);
|
|
}
|
|
|
|
var key = NormalizeKey(upload.Key);
|
|
var contentLength = new FileInfo(sourcePath).Length;
|
|
var existing = await TryGetObjectInfoForUploadAsync(key, cancellationToken).ConfigureAwait(false);
|
|
if (existing?.ContentLength == contentLength)
|
|
{
|
|
Console.WriteLine($"Skipping S3 object {key}; existing object has matching size {FormatBytes(contentLength)}.");
|
|
return false;
|
|
}
|
|
|
|
await UploadFileAsync(upload, cancellationToken).ConfigureAwait(false);
|
|
return true;
|
|
}
|
|
|
|
private async Task UploadFileOnceAsync(
|
|
string sourcePath,
|
|
string key,
|
|
string? contentType,
|
|
string payloadHash,
|
|
long contentLength,
|
|
int attempt,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
var now = DateTimeOffset.UtcNow;
|
|
var requestUri = BuildObjectUri(key);
|
|
Console.WriteLine($"Uploading S3 object {key} ({FormatBytes(contentLength)}), attempt {attempt}/{options.MaxUploadAttempts}.");
|
|
|
|
await using var fileStream = File.OpenRead(sourcePath);
|
|
using var content = new StreamContent(fileStream);
|
|
content.Headers.ContentType = new MediaTypeHeaderValue(string.IsNullOrWhiteSpace(contentType)
|
|
? "application/octet-stream"
|
|
: contentType);
|
|
content.Headers.ContentLength = contentLength;
|
|
|
|
using var request = new HttpRequestMessage(HttpMethod.Put, requestUri)
|
|
{
|
|
Content = content
|
|
};
|
|
SignRequest(request, key, payloadHash, now);
|
|
|
|
using var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
var body = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
|
|
throw new InvalidOperationException($"S3 upload failed for {key}: HTTP {(int)response.StatusCode} {response.ReasonPhrase}. {Truncate(body, 512)}");
|
|
}
|
|
|
|
Console.WriteLine($"Uploaded S3 object {key}.");
|
|
}
|
|
|
|
public async Task EnsureObjectExistsAsync(string key, CancellationToken cancellationToken = default)
|
|
{
|
|
var normalizedKey = NormalizeKey(key);
|
|
var objectInfo = await TryGetObjectInfoAsync(normalizedKey, cancellationToken).ConfigureAwait(false);
|
|
if (objectInfo is null)
|
|
{
|
|
throw new InvalidOperationException($"S3 object verification failed for {normalizedKey}: object was not found.");
|
|
}
|
|
}
|
|
|
|
public async Task<PlondsS3ObjectInfo?> TryGetObjectInfoAsync(string key, CancellationToken cancellationToken = default)
|
|
{
|
|
var normalizedKey = NormalizeKey(key);
|
|
var now = DateTimeOffset.UtcNow;
|
|
var requestUri = BuildObjectUri(normalizedKey);
|
|
|
|
using var request = new HttpRequestMessage(HttpMethod.Head, requestUri);
|
|
SignRequest(request, normalizedKey, EmptyPayloadHash, now);
|
|
|
|
using var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
|
|
if (response.StatusCode is HttpStatusCode.NotFound)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
throw new InvalidOperationException($"S3 object metadata lookup failed for {normalizedKey}: HTTP {(int)response.StatusCode} {response.ReasonPhrase}.");
|
|
}
|
|
|
|
return new PlondsS3ObjectInfo(
|
|
Key: normalizedKey,
|
|
ContentLength: response.Content.Headers.ContentLength,
|
|
ETag: response.Headers.ETag?.Tag);
|
|
}
|
|
|
|
private async Task<PlondsS3ObjectInfo?> TryGetObjectInfoForUploadAsync(string key, CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
return await TryGetObjectInfoAsync(key, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
catch (Exception ex) when (ex is not OperationCanceledException)
|
|
{
|
|
Console.Error.WriteLine($"S3 object metadata lookup for {key} failed; uploading anyway. {ex.Message}");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public string BuildPublicUrl(string key)
|
|
{
|
|
var normalizedKey = NormalizeKey(key);
|
|
if (!string.IsNullOrWhiteSpace(options.PublicBaseKeyPrefix) &&
|
|
(string.Equals(normalizedKey, options.PublicBaseKeyPrefix, StringComparison.OrdinalIgnoreCase) ||
|
|
normalizedKey.StartsWith($"{options.PublicBaseKeyPrefix}/", StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
normalizedKey = normalizedKey[options.PublicBaseKeyPrefix.Length..].TrimStart('/');
|
|
}
|
|
|
|
return $"{options.PublicBaseUrl}/{normalizedKey}";
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (ownsHttpClient)
|
|
{
|
|
httpClient.Dispose();
|
|
}
|
|
}
|
|
|
|
private void SignRequest(HttpRequestMessage request, string key, string payloadHash, DateTimeOffset now)
|
|
{
|
|
var amzDate = now.UtcDateTime.ToString("yyyyMMdd'T'HHmmss'Z'", CultureInfo.InvariantCulture);
|
|
var dateStamp = now.UtcDateTime.ToString("yyyyMMdd", CultureInfo.InvariantCulture);
|
|
var credentialScope = $"{dateStamp}/{options.Region}/{ServiceName}/aws4_request";
|
|
var canonicalUri = BuildCanonicalUri(key);
|
|
var canonicalQueryString = BuildCanonicalQueryString(request.RequestUri);
|
|
var host = request.RequestUri?.IsDefaultPort == true
|
|
? request.RequestUri.Host
|
|
: request.RequestUri?.Authority;
|
|
|
|
if (string.IsNullOrWhiteSpace(host))
|
|
{
|
|
throw new InvalidOperationException("Cannot sign an S3 request without a host.");
|
|
}
|
|
|
|
request.Headers.Host = host;
|
|
request.Headers.TryAddWithoutValidation("x-amz-date", amzDate);
|
|
request.Headers.TryAddWithoutValidation("x-amz-content-sha256", payloadHash);
|
|
|
|
var canonicalHeaders = new StringBuilder();
|
|
canonicalHeaders.Append("host:").Append(host).Append('\n');
|
|
canonicalHeaders.Append("x-amz-content-sha256:").Append(payloadHash).Append('\n');
|
|
canonicalHeaders.Append("x-amz-date:").Append(amzDate).Append('\n');
|
|
|
|
var signedHeaders = "host;x-amz-content-sha256;x-amz-date";
|
|
var canonicalRequest = string.Join('\n',
|
|
[
|
|
request.Method.Method,
|
|
canonicalUri,
|
|
canonicalQueryString,
|
|
canonicalHeaders.ToString(),
|
|
signedHeaders,
|
|
payloadHash
|
|
]);
|
|
|
|
var stringToSign = string.Join('\n',
|
|
[
|
|
"AWS4-HMAC-SHA256",
|
|
amzDate,
|
|
credentialScope,
|
|
Sha256Hex(canonicalRequest)
|
|
]);
|
|
|
|
var signingKey = GetSignatureKey(options.SecretKey, dateStamp, options.Region, ServiceName);
|
|
var signature = HmacSha256Hex(signingKey, stringToSign);
|
|
var authorization = $"AWS4-HMAC-SHA256 Credential={options.AccessKey}/{credentialScope}, SignedHeaders={signedHeaders}, Signature={signature}";
|
|
request.Headers.TryAddWithoutValidation("Authorization", authorization);
|
|
}
|
|
|
|
private Uri BuildObjectUri(string key, string? query = null)
|
|
{
|
|
var bucketPrefix = Uri.EscapeDataString(options.Bucket).Replace("%2F", "/", StringComparison.OrdinalIgnoreCase);
|
|
var path = $"{options.Endpoint.AbsolutePath.TrimEnd('/')}/{bucketPrefix}/{BuildCanonicalKey(key)}";
|
|
var builder = new UriBuilder(options.Endpoint)
|
|
{
|
|
Path = path,
|
|
Query = query ?? string.Empty
|
|
};
|
|
|
|
return builder.Uri;
|
|
}
|
|
|
|
private string BuildCanonicalUri(string key)
|
|
{
|
|
var bucketPrefix = Uri.EscapeDataString(options.Bucket).Replace("%2F", "/", StringComparison.OrdinalIgnoreCase);
|
|
return $"{options.Endpoint.AbsolutePath.TrimEnd('/')}/{bucketPrefix}/{BuildCanonicalKey(key)}";
|
|
}
|
|
|
|
private static string BuildCanonicalKey(string key)
|
|
{
|
|
return string.Join("/", NormalizeKey(key)
|
|
.Split('/', StringSplitOptions.RemoveEmptyEntries)
|
|
.Select(Uri.EscapeDataString));
|
|
}
|
|
|
|
private static string BuildCanonicalQueryString(Uri? uri)
|
|
{
|
|
if (uri is null || string.IsNullOrEmpty(uri.Query))
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
return string.Join("&", uri.Query.TrimStart('?')
|
|
.Split('&', StringSplitOptions.RemoveEmptyEntries)
|
|
.Select(parameter =>
|
|
{
|
|
var parts = parameter.Split('=', 2);
|
|
var name = Uri.UnescapeDataString(parts[0]);
|
|
var value = parts.Length > 1 ? Uri.UnescapeDataString(parts[1]) : string.Empty;
|
|
return new KeyValuePair<string, string>(name, value);
|
|
})
|
|
.OrderBy(parameter => parameter.Key, StringComparer.Ordinal)
|
|
.ThenBy(parameter => parameter.Value, StringComparer.Ordinal)
|
|
.Select(parameter => $"{Uri.EscapeDataString(parameter.Key)}={Uri.EscapeDataString(parameter.Value)}"));
|
|
}
|
|
|
|
private static string NormalizeKey(string value)
|
|
{
|
|
var normalized = value.Replace('\\', '/').Trim('/');
|
|
if (string.IsNullOrWhiteSpace(normalized) || normalized.Contains("..", StringComparison.Ordinal))
|
|
{
|
|
throw new ArgumentException($"Invalid S3 object key: {value}", nameof(value));
|
|
}
|
|
|
|
return normalized;
|
|
}
|
|
|
|
private static string NormalizeOptionalKeyPrefix(string? value)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(value))
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
return NormalizeKey(value);
|
|
}
|
|
|
|
private static Uri NormalizeEndpoint(Uri endpoint)
|
|
{
|
|
if (!endpoint.IsAbsoluteUri)
|
|
{
|
|
throw new ArgumentException("S3 endpoint must be an absolute URI.", nameof(endpoint));
|
|
}
|
|
|
|
var builder = new UriBuilder(endpoint)
|
|
{
|
|
Path = endpoint.AbsolutePath.TrimEnd('/')
|
|
};
|
|
|
|
return builder.Uri;
|
|
}
|
|
|
|
private static string Require(string value, string name)
|
|
{
|
|
return string.IsNullOrWhiteSpace(value)
|
|
? throw new ArgumentException($"{name} is required.", name)
|
|
: value.Trim();
|
|
}
|
|
|
|
private static string Sha256Hex(string value)
|
|
{
|
|
return Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(value))).ToLowerInvariant();
|
|
}
|
|
|
|
private static string Sha256Hex(byte[] value)
|
|
{
|
|
return Convert.ToHexString(SHA256.HashData(value)).ToLowerInvariant();
|
|
}
|
|
|
|
private static string BuildCompleteMultipartUploadBody(IEnumerable<PlondsS3UploadedPart> parts)
|
|
{
|
|
var document = new XDocument(
|
|
new XElement("CompleteMultipartUpload",
|
|
parts.OrderBy(part => part.PartNumber)
|
|
.Select(part => new XElement("Part",
|
|
new XElement("PartNumber", part.PartNumber.ToString(CultureInfo.InvariantCulture)),
|
|
new XElement("ETag", part.ETag)))));
|
|
|
|
return document.ToString(SaveOptions.DisableFormatting);
|
|
}
|
|
|
|
private static byte[] HmacSha256(byte[] key, string data)
|
|
{
|
|
return HMACSHA256.HashData(key, Encoding.UTF8.GetBytes(data));
|
|
}
|
|
|
|
private static string HmacSha256Hex(byte[] key, string data)
|
|
{
|
|
return Convert.ToHexString(HmacSha256(key, data)).ToLowerInvariant();
|
|
}
|
|
|
|
private static byte[] GetSignatureKey(string key, string dateStamp, string regionName, string serviceName)
|
|
{
|
|
var kDate = HmacSha256(Encoding.UTF8.GetBytes($"AWS4{key}"), dateStamp);
|
|
var kRegion = HmacSha256(kDate, regionName);
|
|
var kService = HmacSha256(kRegion, serviceName);
|
|
return HmacSha256(kService, "aws4_request");
|
|
}
|
|
|
|
private static string Truncate(string value, int maxLength)
|
|
{
|
|
if (string.IsNullOrEmpty(value) || value.Length <= maxLength)
|
|
{
|
|
return value;
|
|
}
|
|
|
|
return value[..maxLength];
|
|
}
|
|
|
|
private static bool IsRetriable(Exception exception)
|
|
{
|
|
if (exception is TaskCanceledException or TimeoutException or HttpRequestException)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return exception.InnerException is not null && IsRetriable(exception.InnerException);
|
|
}
|
|
|
|
private static string FormatBytes(long bytes)
|
|
{
|
|
string[] units = ["B", "KB", "MB", "GB"];
|
|
double value = bytes;
|
|
var unit = 0;
|
|
while (value >= 1024 && unit < units.Length - 1)
|
|
{
|
|
value /= 1024;
|
|
unit++;
|
|
}
|
|
|
|
return $"{value:0.##} {units[unit]}";
|
|
}
|
|
|
|
private sealed record PlondsS3UploadedPart(int PartNumber, string ETag);
|
|
}
|