fix: Restore tar archive write performance regressed by padding trim

Author: HofmeisterAn

src/Testcontainers/Containers/TarOutputMemoryStream.cs

@@ -5,7 +5,6 @@ namespace DotNet.Testcontainers.Containers
   using System.Text;
   using System.Threading;
   using System.Threading.Tasks;
-  using DotNet.Testcontainers;
   using DotNet.Testcontainers.Configurations;
   using ICSharpCode.SharpZipLib.Tar;
   using Microsoft.Extensions.Logging;
@@ -17,8 +16,12 @@ public sealed class TarOutputMemoryStream : TarOutputStream
   {
     private readonly string _targetDirectoryPath;
 
+    private readonly MemoryStream _memoryStream;
+
     private readonly ILogger _logger;
 
+    private long _archiveLength;
+
     private long _contentLength;
 
     /// <summary>
@@ -37,8 +40,14 @@ public TarOutputMemoryStream(string targetDirectoryPath, ILogger logger)
     /// </summary>
     /// <param name="logger">The logger.</param>
     public TarOutputMemoryStream(ILogger logger)
-      : base(new MemoryStream(), TarArchiveDefaults.TarBlockFactor, Encoding.Default)
+      : this(new MemoryStream(), logger)
+    {
+    }
+
+    private TarOutputMemoryStream(MemoryStream memoryStream, ILogger logger)
+      : base(memoryStream, Encoding.Default)
     {
+      _memoryStream = memoryStream;
       _logger = logger;
       IsStreamOwner = false;
     }
@@ -90,6 +99,7 @@ await WriteAsync(fileContent, ct)
       await CloseEntryAsync(ct)
         .ConfigureAwait(false);
 
+      _ = Interlocked.Add(ref _archiveLength, GetEntryArchiveLength(tarEntry.Size));
       _ = Interlocked.Add(ref _contentLength, tarEntry.Size);
     }
 
@@ -163,8 +173,46 @@ await stream.CopyToAsync(this, 81920, ct)
         await CloseEntryAsync(ct)
           .ConfigureAwait(false);
 
+        _ = Interlocked.Add(ref _archiveLength, GetEntryArchiveLength(tarEntry.Size));
         _ = Interlocked.Add(ref _contentLength, tarEntry.Size);
       }
     }
+
+    /// <inheritdoc />
+    protected override void Dispose(bool disposing)
+    {
+      base.Dispose(disposing);
+
+      if (!disposing || _archiveLength == 0)
+      {
+        return;
+      }
+
+      // SharpZipLib pads the final record with zeros beyond the two end-of-archive
+      // blocks (the record size is block factor × 512 B). Some archive readers, such
+      // as Podman's, stop reading at the end-of-archive blocks and close the pipe
+      // before the surplus padding has been flushed, causing the sender to fail with
+      // a broken pipe (HTTP 500). Trim the archive to its logical length to drop the
+      // padding while keeping the two end-of-archive blocks intact. See:
+      // https://github.com/testcontainers/testcontainers-dotnet/issues/1683.
+      var length = _archiveLength + 2 * TarBuffer.BlockSize;
+
+      if (_memoryStream.Length > length)
+      {
+        _memoryStream.SetLength(length);
+      }
+    }
+
+    /// <summary>
+    /// Gets the number of bytes a tar entry occupies in the archive. A single header
+    /// block plus its content padded to the next block boundary.
+    /// </summary>
+    /// <param name="size">The tar entry's content length.</param>
+    /// <returns>The block-aligned length of the tar entry.</returns>
+    private static long GetEntryArchiveLength(long size)
+    {
+      var blocks = (size + TarBuffer.BlockSize - 1) / TarBuffer.BlockSize;
+      return TarBuffer.BlockSize + blocks * TarBuffer.BlockSize;
+    }
   }
 }

src/Testcontainers/Images/DockerfileArchive.cs

@@ -192,7 +192,7 @@ public async Task<string> Tar(CancellationToken ct = default)
 
       using (var tarOutputFileStream = new FileStream(dockerfileArchiveFilePath, FileMode.Create, FileAccess.Write))
       {
-        using (var tarOutputStream = new TarOutputStream(tarOutputFileStream, TarArchiveDefaults.TarBlockFactor, Encoding.Default))
+        using (var tarOutputStream = new TarOutputStream(tarOutputFileStream, Encoding.Default))
         {
           tarOutputStream.IsStreamOwner = false;
 

src/Testcontainers/TarArchiveDefaults.cs

@@ -59,6 +59,31 @@ public void TestFileExistsInTarFile()
         Assert.Contains(actual, file => file.EndsWith(_testFile.Name));
     }
 
+    [Fact]
+    [Trait(nameof(DockerCli.DockerPlatform), nameof(DockerCli.DockerPlatform.Linux))]
+    public void TarFileDoesNotContainPaddingBeyondEofBlocks()
+    {
+        // Given
+        _tarOutputMemoryStream.Close();
+        _tarOutputMemoryStream.Seek(0, SeekOrigin.Begin);
+
+        using var buffer = new MemoryStream();
+        _tarOutputMemoryStream.CopyTo(buffer);
+
+        var archive = buffer.ToArray();
+
+        // When
+        var length = archive.Length;
+
+        // Then
+        // The archive holds a single 1-byte file: one header block, one data block and
+        // the two end-of-archive blocks. SharpZipLib's record padding (block factor 20)
+        // would otherwise inflate it to a 10240-byte record boundary.
+        Assert.Equal(4 * TarBuffer.BlockSize, length);
+        Assert.Equal(0, length % TarBuffer.BlockSize);
+        Assert.All(archive.Skip(length - (2 * TarBuffer.BlockSize)), b => Assert.Equal(0, b));
+    }
+
     [UsedImplicitly]
     public sealed class FromResourceMapping : TarOutputMemoryStreamTest, IResourceMapping, IClassFixture<FromResourceMapping.HttpFixture>, IAsyncLifetime
     {