Commit 9580fbcf3596a39ba4c7d7af2f3a1df0e0abb746 | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-02-14 02:53:05-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-03-15 10:48:12-07:00
log	9580fbcf3596a39ba4c7d7af2f3a1df0e0abb746
tree	cbec640f8c4cc29508b33b01b10cf85851233ba4
parent	1fa1484288dc7431f73facb8c423b71670d6914e

build system: capture stderr and report it later

Instead of dumping directly to stderr. This prevents processes running
simultaneously from racing their stderr against each other.

For now it only reports at the end, but an improvement would be to
report as soon as a failed step occurs.

4 files changed, 90 insertions(+), 50 deletions(-)

build.zig
lib
- build_runner.zig
- std
  - Build.zig
  - Build
    Step.zig

build.zig+1-4

 @@ -676,10 +676,7 @@ fn addCxxKnownPath(
 ) !void {
     if (!std.process.can_spawn)
         return error.RequiredLibraryNotFound;
-    const path_padded = try b.exec(&[_][]const u8{
+    const path_padded = b.exec(&.{ ctx.cxx_compiler, b.fmt("-print-file-name={s}", .{objname}) });
-        ctx.cxx_compiler,
-        b.fmt("-print-file-name={s}", .{objname}),
-    });
     var tokenizer = mem.tokenize(u8, path_padded, "\r\n");
     const path_unpadded = tokenizer.next().?;
     if (mem.eql(u8, path_unpadded, objname)) {

lib/build_runner.zig+3-5

...	@@ -318,8 +318,8 @@ fn runStepNames(b: *std.Build, step_names: []const []const u8) !void {	...	@@ -318,8 +318,8 @@ fn runStepNames(b: *std.Build, step_names: []const []const u8) !void {
318	.success => continue,	318	.success => continue,
319	.failure => {	319	.failure => {
320	any_failed = true;	320	any_failed = true;
321	std.debug.print("{s}: {s}\n", .{	321	std.debug.print("{s}: {s}\n{s}", .{
322	s.name, @errorName(s.result.err_code),	322	s.name, @errorName(s.result.err_code), s.result.stderr,
323	});	323	});
324	},	324	},
325	}	325	}
...	@@ -404,9 +404,7 @@ fn workerMakeOneStep(	...	@@ -404,9 +404,7 @@ fn workerMakeOneStep(
404	// *Build object in install header steps that might be able to be removed	404	// *Build object in install header steps that might be able to be removed
405	// by passing the *Build object through the make() functions.	405	// by passing the *Build object through the make() functions.
406	s.make() catch \|err\| {	406	s.make() catch \|err\| {
407	s.result = .{	407	s.result.err_code = err;
408	.err_code = err,
409	};
410	@atomicStore(Step.State, &s.state, .failure, .SeqCst);	408	@atomicStore(Step.State, &s.state, .failure, .SeqCst);
411	return;	409	return;
412	};	410	};

lib/std/Build.zig+81-40

 @@ -1133,17 +1133,24 @@ pub fn spawnChild(self: *Build, argv: []const []const u8) !void {
     return self.spawnChildEnvMap(null, self.env_map, argv);
 }
-fn printCmd(cwd: ?[]const u8, argv: []const []const u8) void {
+fn allocPrintCmd(ally: Allocator, opt_cwd: ?[]const u8, argv: []const []const u8) ![]u8 {
-    if (cwd) |yes_cwd| std.debug.print("cd {s} && ", .{yes_cwd});
+    var buf = ArrayList(u8).init(ally);
+    if (opt_cwd) |cwd| try buf.writer().print("cd {s} && ", .{cwd});
     for (argv) |arg| {
-        std.debug.print("{s} ", .{arg});
+        try buf.writer().print("{s} ", .{arg});
     }
-    std.debug.print("\n", .{});
+    try buf.append('\n');
+    return buf.toOwnedSlice();
+}
+fn printCmd(ally: Allocator, cwd: ?[]const u8, argv: []const []const u8) void {
+    const text = allocPrintCmd(ally, cwd, argv) catch @panic("OOM");
+    std.debug.print("{s}", .{text});
 }
 pub fn spawnChildEnvMap(self: *Build, cwd: ?[]const u8, env_map: *const EnvMap, argv: []const []const u8) !void {
     if (self.verbose) {
-        printCmd(cwd, argv);
+        printCmd(self.allocator, cwd, argv);
     }
     if (!std.process.can_spawn)
 @@ -1162,13 +1169,13 @@ pub fn spawnChildEnvMap(self: *Build, cwd: ?[]const u8, env_map: *const EnvMap,
         .Exited => |code| {
             if (code != 0) {
                 log.err("The following command exited with error code {}:", .{code});
-                printCmd(cwd, argv);
+                printCmd(self.allocator, cwd, argv);
                 return error.UncleanExit;
             }
         },
         else => {
             log.err("The following command terminated unexpectedly:", .{});
-            printCmd(cwd, argv);
+            printCmd(self.allocator, cwd, argv);
             return error.UncleanExit;
         },
 @@ -1381,57 +1388,91 @@ pub fn execAllowFail(
     }
 }
-pub fn execFromStep(self: *Build, argv: []const []const u8, src_step: ?*Step) ![]u8 {
+pub fn execFromStep(b: *Build, argv: []const []const u8, s: *Step) ![]u8 {
     assert(argv.len != 0);
-    if (self.verbose) {
+    if (b.verbose) {
-        printCmd(null, argv);
+        printCmd(b.allocator, null, argv);
     }
     if (!std.process.can_spawn) {
-        if (src_step) |s| log.err("{s}...", .{s.name});
+        s.result.stderr = b.fmt("Unable to spawn the following command: cannot spawn child processes\n{s}", .{
-        log.err("Unable to spawn the following command: cannot spawn child process", .{});
+            try allocPrintCmd(b.allocator, null, argv),
-        printCmd(null, argv);
+        });
-        std.os.abort();
+        return error.CannotSpawnProcesses;
     }
     var code: u8 = undefined;
-    return self.execAllowFail(argv, &code, .Inherit) catch |err| switch (err) {
+    const result = unwrapExecResult(&code, std.ChildProcess.exec(.{
-        error.ExecNotSupported => {
+        .allocator = b.allocator,
-            if (src_step) |s| log.err("{s}...", .{s.name});
+        .argv = argv,
-            log.err("Unable to spawn the following command: cannot spawn child process", .{});
+        .env_map = b.env_map,
-            printCmd(null, argv);
+        .max_output_bytes = 10 * 1024 * 1024,
-            std.os.abort();
+    })) catch |err| switch (err) {
-        },
         error.FileNotFound => {
-            if (src_step) |s| log.err("{s}...", .{s.name});
+            s.result.stderr = b.fmt("unable to spawn the following command: file not found\n{s}", .{
-            log.err("Unable to spawn the following command: file not found", .{});
+                try allocPrintCmd(b.allocator, null, argv),
-            printCmd(null, argv);
+            });
-            std.os.exit(@truncate(u8, code));
+            return error.ExecFailed;
         },
         error.ExitCodeFailure => {
-            if (src_step) |s| log.err("{s}...", .{s.name});
+            s.result.stderr = b.fmt("the following command exited with error code {d}:\n{s}", .{
-            if (self.prominent_compile_errors) {
+                code, try allocPrintCmd(b.allocator, null, argv),
-                log.err("The step exited with error code {d}", .{code});
+            });
-            } else {
+            return error.ExecFailed;
-                log.err("The following command exited with error code {d}:", .{code});
-                printCmd(null, argv);
-            }
-            std.os.exit(@truncate(u8, code));
         },
         error.ProcessTerminated => {
-            if (src_step) |s| log.err("{s}...", .{s.name});
+            s.result.stderr = b.fmt("the following command terminated unexpectedly:\n{s}", .{
-            log.err("The following command terminated unexpectedly:", .{});
+                try allocPrintCmd(b.allocator, null, argv),
-            printCmd(null, argv);
+            });
-            std.os.exit(@truncate(u8, code));
+            return error.ExecFailed;
         },
         else => |e| return e,
     };
+    s.result.stderr = result.stderr;
+    return result.stdout;
 }
-pub fn exec(self: *Build, argv: []const []const u8) ![]u8 {
+fn unwrapExecResult(
-    return self.execFromStep(argv, null);
+    code_ptr: *u8,
+    wrapped: std.ChildProcess.ExecError!std.ChildProcess.ExecResult,
+) !std.ChildProcess.ExecResult {
+    const result = try wrapped;
+    switch (result.term) {
+        .Exited => |code| {
+            code_ptr.* = code;
+            if (code != 0) {
+                return error.ExitCodeFailure;
+            }
+            return result;
+        },
+        .Signal, .Stopped, .Unknown => |code| {
+            _ = code;
+            return error.ProcessTerminated;
+        },
+    }
+}
+/// This is a helper function to be called from build.zig scripts, *not* from
+/// inside step make() functions. If any errors occur, it fails the build with
+/// a helpful message.
+pub fn exec(b: *Build, argv: []const []const u8) []u8 {
+    if (!std.process.can_spawn) {
+        std.debug.print("unable to spawn the following command: cannot spawn child process\n{s}", .{
+            try allocPrintCmd(b.allocator, null, argv),
+        });
+        process.exit(1);
+    }
+    var code: u8 = undefined;
+    return b.execAllowFail(argv, &code, .Inherit) catch |err| {
+        const printed_cmd = allocPrintCmd(b.allocator, null, argv) catch @panic("OOM");
+        std.debug.print("unable to spawn the following command: {s}\n{s}", .{
+            @errorName(err), printed_cmd,
+        });
+        process.exit(1);
+    };
 }
 pub fn addSearchPrefix(self: *Build, search_prefix: []const u8) void {

lib/std/Build/Step.zig+5-1

...	@@ -9,6 +9,7 @@ state: State,	...	@@ -9,6 +9,7 @@ state: State,
9	/// Populated only if state is success.	9	/// Populated only if state is success.
10	result: struct {	10	result: struct {
11	err_code: anyerror,	11	err_code: anyerror,
		12	stderr: []u8,
12	},	13	},
13		14
14	pub const State = enum {	15	pub const State = enum {
...	@@ -78,7 +79,10 @@ pub fn init(	...	@@ -78,7 +79,10 @@ pub fn init(
78	.dependencies = std.ArrayList(*Step).init(allocator),	79	.dependencies = std.ArrayList(*Step).init(allocator),
79	.dependants = .{},	80	.dependants = .{},
80	.state = .precheck_unstarted,	81	.state = .precheck_unstarted,
81	.result = undefined,	82	.result = .{
		83	.err_code = undefined,
		84	.stderr = &.{},
		85	},
82	};	86	};
83	}	87	}
84		88