Exportar archivos a Backblaze B2 en .NET con código abierto

(
  command -v dotnet >/dev/null || { printf 'Install the .NET 10 SDK first.\n' >&2; exit 1; }
  parent="$PWD"
  while :; do
    for config in "$parent"/global.json "$parent"/[Dd]irectory.[Bb]uild.* \
      "$parent"/[Dd]irectory.[Pp]ackages.props "$parent"/[Nn]u[Gg]et.[Cc]onfig; do
      if [ -e "$config" ]; then
        printf 'Choose a directory outside an existing .NET project tree.\n' >&2
        exit 1
      fi
    done
    [ "$parent" = / ] && break
    parent="${parent%/*}"
    [ -n "$parent" ] || parent=/
  done
  mkdir B2Export && cd B2Export &&
    dotnet new console --framework net10.0 --name B2Export --output . &&
    dotnet add package AWSSDK.Core --version 4.0.102.11 &&
    dotnet add package AWSSDK.S3 --version 4.0.104.4
)

using Amazon.Runtime;
using Amazon.S3;
using Amazon.S3.Model;

public static class B2Exporter
{
    public static async Task<int> Main(string[] args)
    {
        using var deadline = new CancellationTokenSource();
        Console.CancelKeyPress += (_, e) => { e.Cancel = true; deadline.Cancel(); };
        try
        {
            if (args.Length != 2) throw new ArgumentException("Pass a local file and an object key.");
            if (args[0].Contains('\uFFFD')) throw new ArgumentException("Unsupported local filename.");
            var seconds = Environment.GetEnvironmentVariable("B2_TIMEOUT_SECONDS") ?? "300";
            if (!int.TryParse(seconds, out var timeout) || timeout < 1 || timeout > 300)
                throw new ArgumentException("B2_TIMEOUT_SECONDS must be between 1 and 300.");
            deadline.CancelAfter(TimeSpan.FromSeconds(timeout));
            var endpoint = new Uri(Required("B2_ENDPOINT"));
            if (endpoint.Scheme != "https" || endpoint.UserInfo.Length != 0 ||
                endpoint.AbsolutePath != "/" || endpoint.Query.Length != 0 || endpoint.Fragment.Length != 0)
                throw new ArgumentException("Use the HTTPS regional endpoint without a bucket or path.");
            var config = new AmazonS3Config
            {
                ServiceURL = endpoint.AbsoluteUri,
                AuthenticationRegion = Required("B2_REGION"),
                ForcePathStyle = true,
                RetryMode = RequestRetryMode.Standard,
                MaxErrorRetry = 2,
                RequestChecksumCalculation = RequestChecksumCalculation.WHEN_REQUIRED,
                ResponseChecksumValidation = ResponseChecksumValidation.WHEN_REQUIRED
            };
            using var client = new AmazonS3Client(
                Required("B2_KEY_ID"), Required("B2_APPLICATION_KEY"), config);
            var bucket = Required("B2_BUCKET");
            var version = await UploadAsync(client, bucket, args[0], args[1], deadline.Token);
            await VerifyAsync(client, bucket, args[0], args[1], version, deadline.Token);
            Console.WriteLine("Uploaded and verified.");
            return 0;
        }
        catch (OperationCanceledException) { Console.Error.WriteLine("Upload canceled or timed out."); }
        catch (AmazonS3Exception error) { Console.Error.WriteLine($"Storage returned HTTP {(int)error.StatusCode}."); }
        catch (Exception) { Console.Error.WriteLine("Upload failed. Check the file and storage configuration."); }
        return 1;
    }

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

    public static async Task<string?> UploadAsync(IAmazonS3 client, string bucket, string path,
        string key, CancellationToken cancellationToken)
    {
        if (string.IsNullOrWhiteSpace(key)) throw new ArgumentException("An object key is required.");
        await using var input = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
        if (input.Length > 64L * 1024 * 1024) throw new IOException("This example accepts at most 64 MiB.");
        var uploaded = await client.PutObjectAsync(new PutObjectRequest
        {
            BucketName = bucket,
            Key = key,
            InputStream = input,
            AutoCloseStream = false,
            ContentType = "application/octet-stream",
            UseChunkEncoding = false
        }, cancellationToken);
        return uploaded.VersionId;
    }

    private static async Task VerifyAsync(IAmazonS3 client, string bucket, string path,
        string key, string? version, CancellationToken cancellationToken)
    {
        using var stored = await client.GetObjectAsync(new GetObjectRequest
        {
            BucketName = bucket,
            Key = key,
            VersionId = version
        }, cancellationToken);
        await using var input = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
        if (stored.ContentLength != input.Length) throw new IOException("Stored length differs.");
        var local = new byte[64 * 1024];
        var remote = new byte[64 * 1024];
        int count;
        while ((count = await input.ReadAsync(local, cancellationToken)) != 0)
        {
            await stored.ResponseStream.ReadExactlyAsync(remote.AsMemory(0, count), cancellationToken);
            if (!local.AsSpan(0, count).SequenceEqual(remote.AsSpan(0, count)))
                throw new IOException("Stored bytes differ.");
        }
        if (await stored.ResponseStream.ReadAsync(remote.AsMemory(0, 1), cancellationToken) != 0)
            throw new IOException("Stored object has extra bytes.");
    }
}

(set -C; printf 'example export\n' > report.txt) &&
  dotnet run --disable-build-servers --project B2Export -- ./report.txt "${B2_OBJECT_KEY:-}"