update zig to 0.15

- use new writer and reader interface
    - archiver streams content to foilz file directly (no need to alloc)

also:
    - use defer more to close resources.
    - use std.Build.allocator in zig build script.
    - pass around a single arena.
    - replaced some helper functions in favour of doing it directly in
      place. (i.e shutil)
    - fmt really long lines

Author: D-Berg

.github/workflows/burrito-xcomp-check.yaml

@@ -20,7 +20,7 @@ jobs:
           elixir-version: "1.18.3"
       - uses: goto-bus-stop/setup-zig@v2
         with:
-          version: 0.14.1
+          version: 0.15.1
       - name: Set up Homebrew
         if: matrix.host == 'macos-latest'
         id: set-up-homebrew

README.md

@@ -110,7 +110,7 @@ We support _targeting_ Windows (x86_64) from MacOS and Linux, we _do not_ offici
 
 You must have the following installed and in your PATH:
 
-* Zig (0.14.0) -- `zig`
+* Zig (0.15.1) -- `zig`
 * XZ -- `xz`
 * 7z -- `7z` (For Windows Targets)
 

build.zig

@@ -8,71 +8,71 @@ const builtin = @import("builtin");
 
 const log = std.log;
 
-const Builder = std.Build;
 const CrossTarget = std.zig.CrossTarget;
 const Mode = std.builtin.Mode;
 const LibExeObjStep = std.build.LibExeObjStep;
 
-var builder: *Builder = undefined;
-var wrapper_exe: *Builder.Step.Compile = undefined;
-
-// Memory allocator
-var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-var allocator = arena.allocator();
-
-pub fn build(b: *Builder) !void {
+pub fn build(b: *std.Build) !void {
     log.info("Zig is building an Elixir binary... ⚡", .{});
 
-    builder = b;
-
     // Run build steps!
-    _ = try run_archiver();
-    _ = try build_wrapper();
+    try run_archiver(b);
+    try build_wrapper(b);
 
     log.info("DONE 🚀", .{});
 }
 
-pub fn run_archiver() !void {
+pub fn run_archiver(b: *std.Build) !void {
     log.info("Generating and compressing release payload... 📦", .{});
 
-    const release_path = try std.process.getEnvVarOwned(allocator, "__BURRITO_RELEASE_PATH");
-    try foilz.pack_directory(release_path, "./payload.foilz");
+    const release_path = try std.process.getEnvVarOwned(b.allocator, "__BURRITO_RELEASE_PATH");
+    try foilz.pack_directory(b.allocator, release_path, "./payload.foilz");
 
     if (builtin.os.tag == .windows) {
-        _ = builder.run(&[_][]const u8{ "cmd", "/C", "xz -9ez --check=crc32 --stdout --keep payload.foilz > src/payload.foilz.xz" });
+        _ = b.run(&[_][]const u8{
+            "cmd",
+            "/C",
+            "xz -9ez --check=crc32 --stdout --keep payload.foilz > src/payload.foilz.xz",
+        });
     } else {
-        _ = builder.run(&[_][]const u8{ "/bin/sh", "-c", "xz -9ez --check=crc32 --stdout --keep payload.foilz > src/payload.foilz.xz" });
+        _ = b.run(&[_][]const u8{
+            "/bin/sh",
+            "-c",
+            "xz -9ez --check=crc32 --stdout --keep payload.foilz > src/payload.foilz.xz",
+        });
     }
 }
 
-pub fn build_wrapper() !void {
+pub fn build_wrapper(b: *std.Build) !void {
     log.info("Building wrapper and embedding payload... 🌯", .{});
 
-    const release_name = try std.process.getEnvVarOwned(allocator, "__BURRITO_RELEASE_NAME");
-    const plugin_path = std.process.getEnvVarOwned(allocator, "__BURRITO_PLUGIN_PATH") catch null;
-    const is_prod = std.process.getEnvVarOwned(allocator, "__BURRITO_IS_PROD") catch "1";
-    const musl_runtime_path = std.process.getEnvVarOwned(allocator, "__BURRITO_MUSL_RUNTIME_PATH") catch "";
-    var opt_level = std.builtin.Mode.Debug;
+    const release_name = try std.process.getEnvVarOwned(b.allocator, "__BURRITO_RELEASE_NAME");
+    const plugin_path = std.process.getEnvVarOwned(b.allocator, "__BURRITO_PLUGIN_PATH") catch null;
+    const is_prod = std.process.getEnvVarOwned(b.allocator, "__BURRITO_IS_PROD") catch "1";
+    const musl_runtime_path = std.process.getEnvVarOwned(b.allocator, "__BURRITO_MUSL_RUNTIME_PATH") catch "";
+    var opt_level = std.builtin.OptimizeMode.Debug;
 
     if (std.mem.eql(u8, is_prod, "1")) {
-        opt_level = std.builtin.Mode.ReleaseSmall;
+        opt_level = std.builtin.OptimizeMode.ReleaseSmall;
     }
 
     var file = try std.fs.cwd().openFile("payload.foilz", .{});
     defer file.close();
     const uncompressed_size = try file.getEndPos();
-    const target = builder.standardTargetOptions(.{});
+    const target = b.standardTargetOptions(.{});
 
-    wrapper_exe = builder.addExecutable(.{
+    const wrapper_exe = b.addExecutable(.{
         .name = release_name,
         // In this case the main source file is merely a path, however, in more
         // complicated build scripts, this could be a generated file.
-        .root_source_file = builder.path("src/wrapper.zig"),
-        .target = target,
-        .optimize = opt_level,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/wrapper.zig"),
+            .target = target,
+            .optimize = opt_level,
+        }),
     });
 
-    const exe_options = builder.addOptions();
+    const exe_options = b.addOptions();
     wrapper_exe.root_module.addOptions("build_options", exe_options);
 
     exe_options.addOption([]const u8, "RELEASE_NAME", release_name);
@@ -82,29 +82,29 @@ pub fn build_wrapper() !void {
     exe_options.addOption([]const u8, "MUSL_RUNTIME_PATH", musl_runtime_path);
 
     if (target.result.os.tag == .windows) {
-        wrapper_exe.addIncludePath(builder.path("src/"));
+        wrapper_exe.addIncludePath(b.path("src/"));
     }
 
     // Link standard C libary to the wrapper
     wrapper_exe.linkSystemLibrary("c");
 
     if (plugin_path) |plugin| {
         log.info("Plugin found! {s} 🔌", .{plugin});
-        const plug_mod = builder.addModule("burrito_plugin", .{
+        const plug_mod = b.addModule("burrito_plugin", .{
             .root_source_file = .{ .cwd_relative = plugin },
         });
         wrapper_exe.root_module.addImport("burrito_plugin", plug_mod);
     } else {
-        const plug_mod = builder.addModule("burrito_plugin", .{
-            .root_source_file = builder.path("_dummy_plugin.zig"),
+        const plug_mod = b.addModule("burrito_plugin", .{
+            .root_source_file = b.path("_dummy_plugin.zig"),
         });
         wrapper_exe.root_module.addImport("burrito_plugin", plug_mod);
     }
 
-    wrapper_exe.addIncludePath(builder.path("src/xz"));
-    wrapper_exe.addCSourceFile(.{ .file = builder.path("src/xz/xz_crc32.c") });
-    wrapper_exe.addCSourceFile(.{ .file = builder.path("src/xz/xz_dec_lzma2.c") });
-    wrapper_exe.addCSourceFile(.{ .file = builder.path("src/xz/xz_dec_stream.c") });
+    wrapper_exe.addIncludePath(b.path("src/xz"));
+    wrapper_exe.addCSourceFile(.{ .file = b.path("src/xz/xz_crc32.c") });
+    wrapper_exe.addCSourceFile(.{ .file = b.path("src/xz/xz_dec_lzma2.c") });
+    wrapper_exe.addCSourceFile(.{ .file = b.path("src/xz/xz_dec_stream.c") });
 
-    builder.installArtifact(wrapper_exe);
+    b.installArtifact(wrapper_exe);
 }

lib/burrito.ex

@@ -2,7 +2,7 @@ defmodule Burrito do
   alias Burrito.Builder
   alias Burrito.Builder.Log
 
-  @zig_version_expected %Version{major: 0, minor: 14, patch: 1}
+  @zig_version_expected %Version{major: 0, minor: 15, patch: 1}
   @openssl_version %Version{major: 3, minor: 5, patch: 1}
   @musl_version %Version{major: 1, minor: 2, patch: 5}
 

src/archiver.zig

@@ -33,6 +33,8 @@
 const builtin = @import("builtin");
 const std = @import("std");
 
+const Allocator = std.mem.Allocator;
+const assert = std.debug.assert;
 const fs = std.fs;
 const log = std.log;
 const mem = std.mem;
@@ -44,22 +46,24 @@ const xz = @cImport(@cInclude("xz.h"));
 const MAGIC = "FOILZ";
 const MAX_READ_SIZE = 1000000000;
 
-pub fn pack_directory(path: []const u8, archive_path: []const u8) anyerror!void {
-    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
+pub fn pack_directory(arena: Allocator, path: []const u8, archive_path: []const u8) anyerror!void {
     // Open a file for the archive
-    _ = try fs.cwd().createFile(archive_path, .{ .truncate = true });
-    const arch_file = try fs.cwd().openFile(archive_path, .{ .mode = .read_write });
-    const foilz_writer = fs.File.writer(arch_file);
+    const arch_file = try fs.cwd().createFile(archive_path, .{ .truncate = true });
+    defer arch_file.close();
+
+    var foilz_write_buf: [1024]u8 = undefined;
+    var foilz_writer = arch_file.writer(&foilz_write_buf);
+    const writer = &foilz_writer.interface;
 
     var dir = try fs.openDirAbsolute(path, .{ .access_sub_paths = true, .iterate = true });
-    var walker = try dir.walk(allocator);
+    defer dir.close();
+
+    var walker = try dir.walk(arena);
+    defer walker.deinit();
 
     var count: u32 = 0;
 
-    try write_magic_number(&foilz_writer);
+    try writer.writeAll(MAGIC);
 
     while (try walker.next()) |entry| {
         if (entry.kind == .file) {
@@ -73,67 +77,44 @@ pub fn pack_directory(path: []const u8, archive_path: []const u8) anyerror!void
             const index = dest_buff[0..replacement_size];
             _ = mem.replace(u8, entry.path, needle, replacement, index);
 
-            // Read the entire contents of the file into a buffer
             const file = try entry.dir.openFile(entry.basename, .{});
             defer file.close();
 
-            // Allocate memory for the file
-            var file_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-            defer file_arena.deinit();
-            const file_allocator = file_arena.allocator();
+            var read_buf: [1024]u8 = undefined;
+            var file_reader = file.reader(&read_buf);
+            const reader = &file_reader.interface;
 
-            // Read the file
-            const file_buffer = try file.readToEndAlloc(file_allocator, MAX_READ_SIZE);
             const stat = try file.stat();
 
             // Write file record to archive
-            try write_file_record(&foilz_writer, index, file_buffer, stat.mode);
+            const name = index;
+            try writer.writeInt(u64, name.len, .little);
+            try writer.writeAll(name);
+            try writer.writeInt(u64, stat.size, .little);
+            if (stat.size > 0) {
+                assert(stat.size == try reader.streamRemaining(writer));
+            }
+            try writer.writeInt(usize, stat.mode, .little);
 
-            count = count + 1;
+            count += 1;
 
             direct_log("\rinfo: 🔍 Files Packed: {}", .{count});
         }
     }
     direct_log("\n", .{});
 
     // Log success
-    log.info("Archived {} files into payload! 📥", .{count});
-
-    // Clean up memory
-    walker.deinit();
-
-    // Close the archive file
-    try write_magic_number(&foilz_writer);
-
-    arch_file.close();
-}
-
-pub fn write_magic_number(foilz_writer: *const fs.File.Writer) !void {
-    _ = try foilz_writer.write(MAGIC);
-}
 
-pub fn write_file_record(foilz_writer: *const fs.File.Writer, name: []const u8, data: []const u8, mode: usize) !void {
-    _ = try foilz_writer.writeInt(u64, name.len, .little);
-    _ = try foilz_writer.write(name);
-    _ = try foilz_writer.writeInt(u64, data.len, .little);
-    if (data.len > 0) {
-        _ = try foilz_writer.write(data);
-    }
-    _ = try foilz_writer.writeInt(usize, mode, .little);
-}
+    try writer.writeAll(MAGIC);
+    try writer.flush();
 
-pub fn validate_magic(first_bytes: []const u8) bool {
-    return mem.eql(u8, first_bytes, MAGIC);
+    log.info("Archived {} files into payload! 📥", .{count});
 }
 
-pub fn unpack_files(data: []const u8, dest_path: []const u8, uncompressed_size: u64) !void {
+pub fn unpack_files(arena: Allocator, data: []const u8, dest_path: []const u8, uncompressed_size: u64) !void {
     // Decompress the data in the payload
 
-    var decompress_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer decompress_arena.deinit();
-    var allocator = decompress_arena.allocator();
-
-    var decompressed: []u8 = try allocator.alloc(u8, uncompressed_size);
+    var decompressed: []u8 = try arena.alloc(u8, uncompressed_size);
 
     var xz_buffer: xz.xz_buf = .{
         .in = data.ptr,
@@ -155,7 +136,7 @@ pub fn unpack_files(data: []const u8, dest_path: []const u8, uncompressed_size:
     }
 
     // Validate the header of the payload
-    if (!validate_magic(decompressed[0..5])) {
+    if (!std.mem.eql(u8, MAGIC, decompressed[0..5])) {
         return error.BadHeader;
     }
 
@@ -190,12 +171,12 @@ pub fn unpack_files(data: []const u8, dest_path: []const u8, uncompressed_size:
 
         //////
         // Write the file
-        const full_file_path = try fs.path.join(allocator, &[_][]const u8{ dest_path[0..], file_name });
+        const full_file_path = try fs.path.join(arena, &[_][]const u8{ dest_path[0..], file_name });
 
         //////
         // Create any directories needed
         const dir_name = fs.path.dirname(file_name);
-        if (dir_name != null) try create_dirs(dest_path[0..], dir_name.?, allocator);
+        if (dir_name != null) try create_dirs(dest_path[0..], dir_name.?, arena);
 
         log.debug("Unpacked File: {s}", .{full_file_path});
 
@@ -223,7 +204,7 @@ pub fn unpack_files(data: []const u8, dest_path: []const u8, uncompressed_size:
     log.debug("Unpacked {} files", .{file_count});
 }
 
-fn create_dirs(dest_path: []const u8, sub_dir_names: []const u8, allocator: std.mem.Allocator) !void {
+fn create_dirs(dest_path: []const u8, sub_dir_names: []const u8, allocator: Allocator) !void {
     var iterator = try fs.path.componentIterator(sub_dir_names);
     var full_dir_path = try fs.path.join(allocator, &[_][]const u8{ dest_path, "" });
 
@@ -244,8 +225,11 @@ fn create_dirs(dest_path: []const u8, sub_dir_names: []const u8, allocator: std.
 
 // Adapted from `std.log`, but without forcing a newline
 fn direct_log(comptime message: []const u8, args: anytype) void {
-    std.debug.lockStdErr();
-    defer std.debug.unlockStdErr();
-    const stderr = std.io.getStdErr().writer(); // Using the same IO as `std.log`
-    nosuspend stderr.print(message, args) catch return;
+    var buffer: [64]u8 = undefined;
+    const stderr = std.debug.lockStderrWriter(&buffer);
+    defer std.debug.unlockStderrWriter();
+    nosuspend {
+        stderr.print(message, args) catch return;
+        stderr.flush() catch return;
+    }
 }

src/erlang_launcher.zig

@@ -99,7 +99,7 @@ pub fn launch(install_dir: []const u8, env_map: *EnvMap, meta: *const MetaStruct
     } else {
         const final_args = try std.mem.concat(allocator, []const u8, &.{ erlang_cli, args_trimmed });
 
-        log.debug("CLI List: {s}", .{final_args});
+        log.debug("CLI List: {any}", .{final_args});
 
         var erl_env_map = EnvMap.init(allocator);
         defer erl_env_map.deinit();