Refactor EXE packaging to use byte sources (#134)

Author: SuperJMN

src/DotnetPackaging.Exe/BuildScript.cs

@@ -1,14 +1,25 @@
+using Zafiro.DivineBytes;
+
 namespace DotnetPackaging.Exe;
 
 public static class BuildScript
 {
-    public static void Build()
+    public static async Task Build()
     {
-        var stub = "build/Stub.exe"; // firmado
-        var installerPayload = "build/installer_payload.zip";
-        var uninstallerPayload = "build/uninstaller_payload.zip";
+        var stub = ByteSource.FromAsyncStreamFactory(() => Task.FromResult<Stream>(File.OpenRead("build/Stub.exe")));
+        var installerPayload = ByteSource.FromAsyncStreamFactory(() => Task.FromResult<Stream>(File.OpenRead("build/installer_payload.zip")));
+        var uninstallerPayload = ByteSource.FromAsyncStreamFactory(() => Task.FromResult<Stream>(File.OpenRead("build/uninstaller_payload.zip")));
+
+        Directory.CreateDirectory("artifacts");
 
-        PayloadAppender.AppendPayload(stub, uninstallerPayload, "artifacts/Uninstaller.exe");
-        PayloadAppender.AppendPayload(stub, installerPayload, "artifacts/Installer.exe");
+        await Persist("artifacts/Uninstaller.exe", PayloadAppender.AppendPayload(stub, uninstallerPayload));
+        await Persist("artifacts/Installer.exe", PayloadAppender.AppendPayload(stub, installerPayload));
+    }
+
+    private static async Task Persist(string path, IByteSource source)
+    {
+        await using var input = source.ToStreamSeekable();
+        await using var output = File.Create(path);
+        await input.CopyToAsync(output);
     }
 }

src/DotnetPackaging.Exe/PayloadAppender.cs

@@ -1,20 +1,32 @@
 using System.Text;
+using Zafiro.DivineBytes;
 
 namespace DotnetPackaging.Exe;
 
 public static class PayloadAppender
 {
-    public static void AppendPayload(string signedStubPath, string payloadZipPath, string outputPath)
+    public static IByteSource AppendPayload(IByteSource signedStub, IByteSource payload)
     {
-        var stubBytes = File.ReadAllBytes(signedStubPath);
-        var payloadBytes = File.ReadAllBytes(payloadZipPath);
-        var lengthBytes = BitConverter.GetBytes((long)payloadBytes.Length);
-        var magicBytes = Encoding.ASCII.GetBytes("DPACKEXE1");
+        return ByteSource.FromAsyncStreamFactory(async () =>
+        {
+            var stubStream = signedStub.ToStreamSeekable();
+            var payloadStream = payload.ToStreamSeekable();
+            var output = new MemoryStream();
 
-        using var output = File.Create(outputPath);
-        output.Write(stubBytes);
-        output.Write(payloadBytes);
-        output.Write(lengthBytes);
-        output.Write(magicBytes);
+            await using (stubStream)
+            await using (payloadStream)
+            {
+                await stubStream.CopyToAsync(output);
+                await payloadStream.CopyToAsync(output);
+
+                var lengthBytes = BitConverter.GetBytes(payloadStream.Length);
+                var magicBytes = Encoding.ASCII.GetBytes("DPACKEXE1");
+
+                await output.WriteAsync(lengthBytes, 0, lengthBytes.Length);
+                await output.WriteAsync(magicBytes, 0, magicBytes.Length);
+                output.Position = 0;
+                return output;
+            }
+        });
     }
 }

src/DotnetPackaging.Exe/SimpleExePacker.cs

@@ -1,6 +1,8 @@
 using System.IO.Compression;
 using System.Text.Json;
 using CSharpFunctionalExtensions;
+using Zafiro.DivineBytes;
+using Zafiro.FileSystem.Core;
 
 namespace DotnetPackaging.Exe;
 
@@ -15,147 +17,183 @@ public static async Task<Result> Build(
         Maybe<byte[]> logoBytes,
         string outputPath)
     {
-        var tempRoot = string.Empty;
-        try
+        if (!File.Exists(stubPath))
         {
-            if (!File.Exists(stubPath))
-            {
-                return Result.Failure($"Stub not found: {stubPath}");
-            }
-
-            if (!Directory.Exists(publishDir))
-            {
-                return Result.Failure($"Publish directory not found: {publishDir}");
-            }
-
-            var outputDirectory = Path.GetDirectoryName(outputPath);
-            if (string.IsNullOrWhiteSpace(outputDirectory))
-            {
-                return Result.Failure("Output directory cannot be determined.");
-            }
-
-            Directory.CreateDirectory(outputDirectory);
+            return Result.Failure($"Stub not found: {stubPath}");
+        }
 
-            tempRoot = Path.Combine(Path.GetTempPath(), "dp-exe-" + Guid.NewGuid());
-            Directory.CreateDirectory(tempRoot);
+        if (!Directory.Exists(publishDir))
+        {
+            return Result.Failure($"Publish directory not found: {publishDir}");
+        }
 
-            var uninstallerPayloadRoot = Path.Combine(tempRoot, "uninstaller_payload");
-            Directory.CreateDirectory(uninstallerPayloadRoot);
-            await WriteMetadata(uninstallerPayloadRoot, metadata);
-            await WriteSupportStub(uninstallerPayloadRoot, stubPath);
+        var outputDirectory = Path.GetDirectoryName(outputPath);
+        if (string.IsNullOrWhiteSpace(outputDirectory))
+        {
+            return Result.Failure("Output directory cannot be determined.");
+        }
 
-            var uninstallerPayloadZip = Path.Combine(outputDirectory, "uninstaller_payload.zip");
-            CreatePayloadZip(uninstallerPayloadRoot, uninstallerPayloadZip);
+        var publishContainerResult = BuildContainerFromDirectory(publishDir);
+        if (publishContainerResult.IsFailure)
+        {
+            return Result.Failure(publishContainerResult.Error);
+        }
 
-            var uninstallerOutput = Path.Combine(outputDirectory, "Uninstaller.exe");
-            PayloadAppender.AppendPayload(stubPath, uninstallerPayloadZip, uninstallerOutput);
+        var stubSource = ByteSource.FromAsyncStreamFactory(() => Task.FromResult<Stream>(File.OpenRead(stubPath)));
+        var logoSource = logoBytes.Map(bytes => (IByteSource)ByteSource.FromBytes(bytes));
+        var bundleResult = await Build(stubSource, publishContainerResult.Value, metadata, logoSource);
+        if (bundleResult.IsFailure)
+        {
+            return Result.Failure(bundleResult.Error);
+        }
 
-            var installerPayloadRoot = Path.Combine(tempRoot, "installer_payload");
-            Directory.CreateDirectory(installerPayloadRoot);
-            await WriteMetadata(installerPayloadRoot, metadata);
-            CopyDirectory(publishDir, Path.Combine(installerPayloadRoot, "Content"));
-            CopySupportBinary(uninstallerOutput, Path.Combine(installerPayloadRoot, "Support"));
-            await WriteLogo(installerPayloadRoot, logoBytes);
+        Directory.CreateDirectory(outputDirectory);
+        var uninstallerPath = Path.Combine(outputDirectory, "Uninstaller.exe");
+        await Persist(bundleResult.Value.Installer, outputPath);
+        await Persist(bundleResult.Value.Uninstaller, uninstallerPath);
 
-            var installerPayloadZip = Path.Combine(outputDirectory, "installer_payload.zip");
-            CreatePayloadZip(installerPayloadRoot, installerPayloadZip);
+        return Result.Success();
+    }
 
-            PayloadAppender.AppendPayload(stubPath, installerPayloadZip, outputPath);
-            return Result.Success();
-        }
-        catch (Exception ex)
+    public static async Task<Result<SimpleExeBundle>> Build(
+        IByteSource stub,
+        IContainer publishContent,
+        InstallerMetadata metadata,
+        Maybe<IByteSource> logoBytes)
+    {
+        var metadataSource = Serialize(metadata);
+        var uninstallerPayloadResult = await BuildUninstallerPayload(stub, metadataSource);
+        if (uninstallerPayloadResult.IsFailure)
         {
-            return Result.Failure(ex.Message);
+            return Result.Failure<SimpleExeBundle>(uninstallerPayloadResult.Error);
         }
-        finally
+
+        var uninstaller = new Resource("Uninstaller.exe", PayloadAppender.AppendPayload(stub, uninstallerPayloadResult.Value));
+
+        var installerPayloadResult = await BuildInstallerPayload(metadataSource, publishContent, logoBytes, uninstaller);
+        if (installerPayloadResult.IsFailure)
         {
-            TryDeleteTempDirectories();
+            return Result.Failure<SimpleExeBundle>(installerPayloadResult.Error);
         }
 
-        void TryDeleteTempDirectories()
-        {
-            if (string.IsNullOrWhiteSpace(tempRoot))
-            {
-                return;
-            }
+        var installer = new Resource("Installer.exe", PayloadAppender.AppendPayload(stub, installerPayloadResult.Value));
 
-            try
-            {
-                Directory.Delete(tempRoot, true);
-            }
-            catch
-            {
-                // best effort cleanup
-            }
-        }
+        return Result.Success(new SimpleExeBundle(installer, uninstaller));
     }
 
-    private static void CreatePayloadZip(string sourceDirectory, string destinationZip)
+    private static async Task Persist(INamedByteSource artifact, string path)
     {
-        Directory.CreateDirectory(Path.GetDirectoryName(destinationZip)!);
-        if (File.Exists(destinationZip))
-        {
-            File.Delete(destinationZip);
-        }
-
-        ZipFile.CreateFromDirectory(sourceDirectory, destinationZip, CompressionLevel.Optimal, includeBaseDirectory: false);
+        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+        await using var input = artifact.ToStreamSeekable();
+        await using var output = File.Create(path);
+        await input.CopyToAsync(output);
     }
 
-    private static async Task WriteMetadata(string destinationDirectory, InstallerMetadata meta)
+    private static IByteSource Serialize(InstallerMetadata metadata)
     {
-        Directory.CreateDirectory(destinationDirectory);
-        var metadataPath = Path.Combine(destinationDirectory, "metadata.json");
-        await using var stream = File.Create(metadataPath);
-        await JsonSerializer.SerializeAsync(stream, meta, new JsonSerializerOptions
+        var json = JsonSerializer.Serialize(metadata, new JsonSerializerOptions
         {
             PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
             WriteIndented = false
         });
-    }
 
-    private static async Task WriteLogo(string payloadRoot, Maybe<byte[]> logoBytes)
-    {
-        await logoBytes.Match(
-            async bytes =>
-            {
-                var brandingDir = Path.Combine(payloadRoot, "Branding");
-                Directory.CreateDirectory(brandingDir);
-                var logoPath = Path.Combine(brandingDir, Path.GetFileName(BrandingLogoEntry));
-                await File.WriteAllBytesAsync(logoPath, bytes);
-            },
-            () => Task.CompletedTask);
+        return ByteSource.FromString(json);
     }
 
-    private static async Task WriteSupportStub(string payloadRoot, string stubPath)
+    private static async Task<Result<IByteSource>> BuildUninstallerPayload(IByteSource stub, IByteSource metadataSource)
     {
-        var supportDir = Path.Combine(payloadRoot, "Support");
-        Directory.CreateDirectory(supportDir);
-        await using var input = File.OpenRead(stubPath);
-        await using var output = File.Create(Path.Combine(supportDir, "Uninstaller.exe"));
-        await input.CopyToAsync(output);
+        var entries = new Dictionary<string, IByteSource>(StringComparer.Ordinal)
+        {
+            ["metadata.json"] = metadataSource,
+            [$"Support/{"Uninstaller.exe"}"] = stub
+        };
+
+        var containerResult = entries.ToRootContainer();
+        if (containerResult.IsFailure)
+        {
+            return Result.Failure<IByteSource>(containerResult.Error);
+        }
+
+        return await CreatePayloadZip(containerResult.Value);
     }
 
-    private static void CopySupportBinary(string uninstallerPath, string supportRoot)
+    private static async Task<Result<IByteSource>> BuildInstallerPayload(
+        IByteSource metadataSource,
+        IContainer publishContent,
+        Maybe<IByteSource> logoBytes,
+        INamedByteSource uninstaller)
     {
-        Directory.CreateDirectory(supportRoot);
-        var destination = Path.Combine(supportRoot, "Uninstaller.exe");
-        File.Copy(uninstallerPath, destination, overwrite: true);
+        var entries = new Dictionary<string, IByteSource>(StringComparer.Ordinal)
+        {
+            ["metadata.json"] = metadataSource,
+            [$"Support/{uninstaller.Name}"] = uninstaller
+        };
+
+        foreach (var file in publishContent.ResourcesWithPathsRecursive())
+        {
+            var entryPath = $"Content/{file.FullPath().ToString().Replace('\\', '/')}";
+            entries[entryPath] = file;
+        }
+
+        logoBytes.Execute(bytes => entries[BrandingLogoEntry] = bytes);
+
+        var containerResult = entries.ToRootContainer();
+        if (containerResult.IsFailure)
+        {
+            return Result.Failure<IByteSource>(containerResult.Error);
+        }
+
+        return await CreatePayloadZip(containerResult.Value);
     }
 
-    private static void CopyDirectory(string sourceDir, string destinationDir)
+    private static Result<RootContainer> BuildContainerFromDirectory(string root)
     {
-        foreach (var directory in Directory.EnumerateDirectories(sourceDir, "*", SearchOption.AllDirectories))
+        try
         {
-            var relative = Path.GetRelativePath(sourceDir, directory);
-            Directory.CreateDirectory(Path.Combine(destinationDir, relative));
+            var files = Directory
+                .EnumerateFiles(root, "*", SearchOption.AllDirectories)
+                .ToDictionary(
+                    file => Path.GetRelativePath(root, file).Replace("\\", "/"),
+                    file => (IByteSource)ByteSource.FromAsyncStreamFactory(() => Task.FromResult<Stream>(File.OpenRead(file))),
+                    StringComparer.Ordinal);
+
+            return files.ToRootContainer();
         }
-
-        foreach (var file in Directory.EnumerateFiles(sourceDir, "*", SearchOption.AllDirectories))
+        catch (Exception ex)
         {
-            var relative = Path.GetRelativePath(sourceDir, file);
-            var destination = Path.Combine(destinationDir, relative);
-            Directory.CreateDirectory(Path.GetDirectoryName(destination)!);
-            File.Copy(file, destination, overwrite: true);
+            return Result.Failure<RootContainer>($"Failed to read directory '{root}': {ex.Message}");
         }
     }
+
+    private static Task<Result<IByteSource>> CreatePayloadZip(IContainer container)
+    {
+        return Task.FromResult(Result.Success(CreateZipSource(container)));
+    }
+
+    private static IByteSource CreateZipSource(IContainer container)
+    {
+        return ByteSource.FromAsyncStreamFactory(async () =>
+        {
+            var zipStream = new MemoryStream();
+
+            await using (var zip = new ZipArchive(zipStream, ZipArchiveMode.Create, leaveOpen: true))
+            {
+                foreach (var resource in container.ResourcesWithPathsRecursive())
+                {
+                    var entry = zip.CreateEntry(resource.FullPath().ToString().Replace('\\', '/'), CompressionLevel.Optimal);
+                    await using var entryStream = entry.Open();
+                    await using var resourceStream = resource.ToStreamSeekable();
+                    await resourceStream.CopyToAsync(entryStream);
+                }
+            }
+
+            zipStream.Position = 0;
+            var final = new MemoryStream();
+            await zipStream.CopyToAsync(final);
+            final.Position = 0;
+            return final;
+        });
+    }
 }
+
+public sealed record SimpleExeBundle(INamedByteSource Installer, INamedByteSource Uninstaller);