Revert "Refactor EXE packaging to use byte sources (#134)"

This reverts commit bea83b6

Author: SuperJMN

src/DotnetPackaging.Exe/BuildScript.cs

@@ -1,25 +1,14 @@
-using Zafiro.DivineBytes;
-
 namespace DotnetPackaging.Exe;
 
 public static class BuildScript
 {
-    public static async Task Build()
+    public static void Build()
     {
-        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");
+        var stub = "build/Stub.exe"; // firmado
+        var installerPayload = "build/installer_payload.zip";
+        var uninstallerPayload = "build/uninstaller_payload.zip";
 
-        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);
+        PayloadAppender.AppendPayload(stub, uninstallerPayload, "artifacts/Uninstaller.exe");
+        PayloadAppender.AppendPayload(stub, installerPayload, "artifacts/Installer.exe");
     }
 }

src/DotnetPackaging.Exe/PayloadAppender.cs

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

src/DotnetPackaging.Exe/SimpleExePacker.cs

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