Exportación sin esfuerzo de archivos a OpenStack Swift en .NET C#

dotnet new console --framework net10.0 --name SwiftExport
cd SwiftExport

using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text.Json;

public static class Program
{
    public static async Task<int> Main(string[] args)
    {
        using var deadline = new CancellationTokenSource(TimeSpan.FromMinutes(5));
        Console.CancelKeyPress += (_, e) => { e.Cancel = true; deadline.Cancel(); };
        try
        {
            if (args.Length != 3) throw new ArgumentException("Pass container, object key, and local file.");
            var endpoint = new Uri(Required("SWIFT_STORAGE_URL"));
            if (endpoint.Scheme != "https" || endpoint.UserInfo.Length != 0 ||
                endpoint.Query.Length != 0 || endpoint.Fragment.Length != 0)
                throw new ArgumentException("Use the HTTPS account endpoint from the service catalog.");
            using var handler = new SocketsHttpHandler { AllowAutoRedirect = false, MaxConnectionsPerServer = 4 };
            using var http = new HttpClient(handler) { Timeout = Timeout.InfiniteTimeSpan };
            var exporter = new SwiftExporter(http, endpoint, Required("SWIFT_TOKEN"));
            await exporter.UploadAsync(args[0], args[1], args[2], deadline.Token);
            Console.WriteLine("Uploaded.");
            return 0;
        }
        catch (OperationCanceledException) { Console.Error.WriteLine("Upload canceled or timed out."); }
        catch (HttpRequestException error) { Console.Error.WriteLine($"Swift request failed (HTTP {error.StatusCode})."); }
        catch (Exception) { Console.Error.WriteLine("Upload failed. Check the file and Swift configuration."); }
        return 1;
    }

    private static string Required(string name) =>
        Environment.GetEnvironmentVariable(name) is { Length: > 0 } value
            ? value : throw new ArgumentException($"Missing {name}.");
}

public sealed class SwiftExporter(HttpClient http, Uri endpoint, string token)
{
    private const int SegmentSize = 5 * 1024 * 1024;
    private const int MaxSegments = 1000;

    private static string Encode(string value)
    {
        var parts = value.Split('/');
        if (parts.Any(part => part.Length == 0 || part == "." || part == ".."))
            throw new ArgumentException("Use nonempty path segments other than dot or dot-dot.");
        return string.Join("/", parts.Select(Uri.EscapeDataString));
    }

    private async Task<string?> PutAsync(string path, HttpContent content,
        bool container, CancellationToken ct, string? etag = null, string query = "")
    {
        content.Headers.ContentType ??= new MediaTypeHeaderValue("application/octet-stream");
        using var request = new HttpRequestMessage(HttpMethod.Put,
            endpoint.AbsoluteUri.TrimEnd('/') + "/" + Encode(path) + query) { Content = content };
        request.Headers.Add("X-Auth-Token", token);
        if (etag != null) request.Headers.Add("ETag", etag);
        using var response = await http.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, ct);
        var status = (int)response.StatusCode;
        if (status != 201 && !(container && status == 202))
            throw new HttpRequestException("Unexpected Swift response.", null, response.StatusCode);
        return response.Headers.ETag?.Tag.Trim('"');
    }

    public async Task UploadAsync(string container, string key, string file, CancellationToken ct)
    {
        if (container.Contains('/')) throw new ArgumentException("A container cannot contain slashes.");
        Encode(container);
        Encode(key);
        await using var input = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read);
        long length = input.Length;
        if (length > (long)SegmentSize * MaxSegments) throw new IOException("File exceeds the example limit.");
        await PutAsync(container, new ByteArrayContent([]), true, ct);
        if (length == 0)
        {
            await PutAsync(container + "/" + key, new ByteArrayContent([]), false, ct);
            return;
        }

        string segments = container + "_segments";
        await PutAsync(segments, new ByteArrayContent([]), true, ct);
        string version = Guid.NewGuid().ToString("N");
        var manifest = new List<object>();
        var buffer = new byte[SegmentSize];
        long remaining = length;
        for (int index = 0; remaining > 0; index++)
        {
            int count = (int)Math.Min(remaining, SegmentSize);
            await input.ReadExactlyAsync(buffer.AsMemory(0, count), ct);
            string hash = Convert.ToHexString(MD5.HashData(buffer.AsSpan(0, count))).ToLowerInvariant();
            string name = $"{segments}/{version}/{index:D8}";
            using var content = new ByteArrayContent(buffer, 0, count);
            content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
            string? returned = await PutAsync(name, content, false, ct, hash);
            if (!string.Equals(hash, returned, StringComparison.OrdinalIgnoreCase))
                throw new IOException("Swift did not confirm the segment checksum.");
            manifest.Add(new { path = "/" + name, etag = hash, size_bytes = count });
            remaining -= count;
        }
        if (input.Length != length || input.ReadByte() != -1) throw new IOException("The input file changed.");
        using var manifestContent = new StringContent(JsonSerializer.Serialize(manifest));
        manifestContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
        await PutAsync(container + "/" + key, manifestContent, false, ct,
            query: "?multipart-manifest=put");
    }
}

printf 'example export\n' > report.txt
dotnet run -- exports 'reports/report #1.txt' report.txt