| ... | @@ -1,327 +0,0 @@ |
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // Copyright (c) 2015-2021 Zig Contributors |
| 3 | // This file is part of [zig](https://ziglang.org/), which is MIT licensed. |
| 4 | // The MIT license requires this copyright notice to be included in all copies |
| 5 | // and substantial portions of the software. |
| 6 | const std = @import("../std.zig"); |
| 7 | const builtin = std.builtin; |
| 8 | const build = std.build; |
| 9 | const Step = build.Step; |
| 10 | const Builder = build.Builder; |
| 11 | const LibExeObjStep = build.LibExeObjStep; |
| 12 | const WriteFileStep = build.WriteFileStep; |
| 13 | const fs = std.fs; |
| 14 | const mem = std.mem; |
| 15 | const process = std.process; |
| 16 | const ArrayList = std.ArrayList; |
| 17 | const BufMap = std.BufMap; |
| 18 | const warn = std.debug.warn; |
| 19 | |
| 20 | const max_stdout_size = 1 * 1024 * 1024; // 1 MiB |
| 21 | |
| 22 | pub const RunStep = struct { |
| 23 | step: Step, |
| 24 | builder: *Builder, |
| 25 | |
| 26 | /// See also addArg and addArgs to modifying this directly |
| 27 | argv: ArrayList(Arg), |
| 28 | |
| 29 | /// Set this to modify the current working directory |
| 30 | cwd: ?[]const u8, |
| 31 | |
| 32 | /// Override this field to modify the environment, or use setEnvironmentVariable |
| 33 | env_map: ?*BufMap, |
| 34 | |
| 35 | stdout_action: StdIoAction = .inherit, |
| 36 | stderr_action: StdIoAction = .inherit, |
| 37 | |
| 38 | stdin_behavior: std.ChildProcess.StdIo = .Inherit, |
| 39 | |
| 40 | expected_exit_code: u8 = 0, |
| 41 | |
| 42 | pub const StdIoAction = union(enum) { |
| 43 | inherit, |
| 44 | ignore, |
| 45 | expect_exact: []const u8, |
| 46 | expect_matches: []const []const u8, |
| 47 | }; |
| 48 | |
| 49 | pub const Arg = union(enum) { |
| 50 | artifact: *LibExeObjStep, |
| 51 | file_source: build.FileSource, |
| 52 | bytes: []u8, |
| 53 | }; |
| 54 | |
| 55 | pub fn create(builder: *Builder, name: []const u8) *RunStep { |
| 56 | const self = builder.allocator.create(RunStep) catch unreachable; |
| 57 | self.* = RunStep{ |
| 58 | .builder = builder, |
| 59 | .step = Step.init(.Run, name, builder.allocator, make), |
| 60 | .argv = ArrayList(Arg).init(builder.allocator), |
| 61 | .cwd = null, |
| 62 | .env_map = null, |
| 63 | }; |
| 64 | return self; |
| 65 | } |
| 66 | |
| 67 | pub fn addArtifactArg(self: *RunStep, artifact: *LibExeObjStep) void { |
| 68 | self.argv.append(Arg{ .artifact = artifact }) catch unreachable; |
| 69 | self.step.dependOn(&artifact.step); |
| 70 | } |
| 71 | |
| 72 | pub fn addFileSourceArg(self: *RunStep, file_source: build.FileSource) void { |
| 73 | self.argv.append(Arg{ |
| 74 | .file_source = file_source.dupe(self.builder), |
| 75 | }) catch unreachable; |
| 76 | file_source.addStepDependencies(&self.step); |
| 77 | } |
| 78 | |
| 79 | pub fn addArg(self: *RunStep, arg: []const u8) void { |
| 80 | self.argv.append(Arg{ .bytes = self.builder.dupe(arg) }) catch unreachable; |
| 81 | } |
| 82 | |
| 83 | pub fn addArgs(self: *RunStep, args: []const []const u8) void { |
| 84 | for (args) |arg| { |
| 85 | self.addArg(arg); |
| 86 | } |
| 87 | } |
| 88 | |
| 89 | pub fn clearEnvironment(self: *RunStep) void { |
| 90 | const new_env_map = self.builder.allocator.create(BufMap) catch unreachable; |
| 91 | new_env_map.* = BufMap.init(self.builder.allocator); |
| 92 | self.env_map = new_env_map; |
| 93 | } |
| 94 | |
| 95 | pub fn addPathDir(self: *RunStep, search_path: []const u8) void { |
| 96 | const env_map = self.getEnvMap(); |
| 97 | |
| 98 | var key: []const u8 = undefined; |
| 99 | var prev_path: ?[]const u8 = undefined; |
| 100 | if (builtin.os.tag == .windows) { |
| 101 | key = "Path"; |
| 102 | prev_path = env_map.get(key); |
| 103 | if (prev_path == null) { |
| 104 | key = "PATH"; |
| 105 | prev_path = env_map.get(key); |
| 106 | } |
| 107 | } else { |
| 108 | key = "PATH"; |
| 109 | prev_path = env_map.get(key); |
| 110 | } |
| 111 | |
| 112 | if (prev_path) |pp| { |
| 113 | const new_path = self.builder.fmt("{s}" ++ [1]u8{fs.path.delimiter} ++ "{s}", .{ pp, search_path }); |
| 114 | env_map.put(key, new_path) catch unreachable; |
| 115 | } else { |
| 116 | env_map.put(key, self.builder.dupePath(search_path)) catch unreachable; |
| 117 | } |
| 118 | } |
| 119 | |
| 120 | pub fn getEnvMap(self: *RunStep) *BufMap { |
| 121 | return self.env_map orelse { |
| 122 | const env_map = self.builder.allocator.create(BufMap) catch unreachable; |
| 123 | env_map.* = process.getEnvMap(self.builder.allocator) catch unreachable; |
| 124 | self.env_map = env_map; |
| 125 | return env_map; |
| 126 | }; |
| 127 | } |
| 128 | |
| 129 | pub fn setEnvironmentVariable(self: *RunStep, key: []const u8, value: []const u8) void { |
| 130 | const env_map = self.getEnvMap(); |
| 131 | // Note: no need to dupe these strings because BufMap does it internally. |
| 132 | env_map.put(key, value) catch unreachable; |
| 133 | } |
| 134 | |
| 135 | pub fn expectStdErrEqual(self: *RunStep, bytes: []const u8) void { |
| 136 | self.stderr_action = .{ .expect_exact = self.builder.dupe(bytes) }; |
| 137 | } |
| 138 | |
| 139 | pub fn expectStdOutEqual(self: *RunStep, bytes: []const u8) void { |
| 140 | self.stdout_action = .{ .expect_exact = self.builder.dupe(bytes) }; |
| 141 | } |
| 142 | |
| 143 | fn stdIoActionToBehavior(action: StdIoAction) std.ChildProcess.StdIo { |
| 144 | return switch (action) { |
| 145 | .ignore => .Ignore, |
| 146 | .inherit => .Inherit, |
| 147 | .expect_exact, .expect_matches => .Pipe, |
| 148 | }; |
| 149 | } |
| 150 | |
| 151 | fn make(step: *Step) !void { |
| 152 | const self = @fieldParentPtr(RunStep, "step", step); |
| 153 | |
| 154 | const cwd = if (self.cwd) |cwd| self.builder.pathFromRoot(cwd) else self.builder.build_root; |
| 155 | |
| 156 | var argv_list = ArrayList([]const u8).init(self.builder.allocator); |
| 157 | for (self.argv.items) |arg| { |
| 158 | switch (arg) { |
| 159 | .bytes => |bytes| try argv_list.append(bytes), |
| 160 | .file_source => |file| try argv_list.append(file.getPath(self.builder)), |
| 161 | .artifact => |artifact| { |
| 162 | if (artifact.target.isWindows()) { |
| 163 | // On Windows we don't have rpaths so we have to add .dll search paths to PATH |
| 164 | self.addPathForDynLibs(artifact); |
| 165 | } |
| 166 | const executable_path = artifact.installed_path orelse artifact.getOutputPath(); |
| 167 | try argv_list.append(executable_path); |
| 168 | }, |
| 169 | } |
| 170 | } |
| 171 | |
| 172 | const argv = argv_list.items; |
| 173 | |
| 174 | const child = std.ChildProcess.init(argv, self.builder.allocator) catch unreachable; |
| 175 | defer child.deinit(); |
| 176 | |
| 177 | child.cwd = cwd; |
| 178 | child.env_map = self.env_map orelse self.builder.env_map; |
| 179 | |
| 180 | child.stdin_behavior = self.stdin_behavior; |
| 181 | child.stdout_behavior = stdIoActionToBehavior(self.stdout_action); |
| 182 | child.stderr_behavior = stdIoActionToBehavior(self.stderr_action); |
| 183 | |
| 184 | if (self.builder.verbose) { |
| 185 | for (argv) |arg| { |
| 186 | warn("{s} ", .{arg}); |
| 187 | } |
| 188 | warn("\n", .{}); |
| 189 | } |
| 190 | |
| 191 | child.spawn() catch |err| { |
| 192 | warn("Unable to spawn {s}: {s}\n", .{ argv[0], @errorName(err) }); |
| 193 | return err; |
| 194 | }; |
| 195 | |
| 196 | // TODO need to poll to read these streams to prevent a deadlock (or rely on evented I/O). |
| 197 | |
| 198 | var stdout: ?[]const u8 = null; |
| 199 | defer if (stdout) |s| self.builder.allocator.free(s); |
| 200 | |
| 201 | switch (self.stdout_action) { |
| 202 | .expect_exact, .expect_matches => { |
| 203 | stdout = child.stdout.?.reader().readAllAlloc(self.builder.allocator, max_stdout_size) catch unreachable; |
| 204 | }, |
| 205 | .inherit, .ignore => {}, |
| 206 | } |
| 207 | |
| 208 | var stderr: ?[]const u8 = null; |
| 209 | defer if (stderr) |s| self.builder.allocator.free(s); |
| 210 | |
| 211 | switch (self.stderr_action) { |
| 212 | .expect_exact, .expect_matches => { |
| 213 | stderr = child.stderr.?.reader().readAllAlloc(self.builder.allocator, max_stdout_size) catch unreachable; |
| 214 | }, |
| 215 | .inherit, .ignore => {}, |
| 216 | } |
| 217 | |
| 218 | const term = child.wait() catch |err| { |
| 219 | warn("Unable to spawn {s}: {s}\n", .{ argv[0], @errorName(err) }); |
| 220 | return err; |
| 221 | }; |
| 222 | |
| 223 | switch (term) { |
| 224 | .Exited => |code| { |
| 225 | if (code != self.expected_exit_code) { |
| 226 | warn("The following command exited with error code {} (expected {}):\n", .{ |
| 227 | code, |
| 228 | self.expected_exit_code, |
| 229 | }); |
| 230 | printCmd(cwd, argv); |
| 231 | return error.UncleanExit; |
| 232 | } |
| 233 | }, |
| 234 | else => { |
| 235 | warn("The following command terminated unexpectedly:\n", .{}); |
| 236 | printCmd(cwd, argv); |
| 237 | return error.UncleanExit; |
| 238 | }, |
| 239 | } |
| 240 | |
| 241 | switch (self.stderr_action) { |
| 242 | .inherit, .ignore => {}, |
| 243 | .expect_exact => |expected_bytes| { |
| 244 | if (!mem.eql(u8, expected_bytes, stderr.?)) { |
| 245 | warn( |
| 246 | \\ |
| 247 | \\========= Expected this stderr: ========= |
| 248 | \\{s} |
| 249 | \\========= But found: ==================== |
| 250 | \\{s} |
| 251 | \\ |
| 252 | , .{ expected_bytes, stderr.? }); |
| 253 | printCmd(cwd, argv); |
| 254 | return error.TestFailed; |
| 255 | } |
| 256 | }, |
| 257 | .expect_matches => |matches| for (matches) |match| { |
| 258 | if (mem.indexOf(u8, stderr.?, match) == null) { |
| 259 | warn( |
| 260 | \\ |
| 261 | \\========= Expected to find in stderr: ========= |
| 262 | \\{s} |
| 263 | \\========= But stderr does not contain it: ===== |
| 264 | \\{s} |
| 265 | \\ |
| 266 | , .{ match, stderr.? }); |
| 267 | printCmd(cwd, argv); |
| 268 | return error.TestFailed; |
| 269 | } |
| 270 | }, |
| 271 | } |
| 272 | |
| 273 | switch (self.stdout_action) { |
| 274 | .inherit, .ignore => {}, |
| 275 | .expect_exact => |expected_bytes| { |
| 276 | if (!mem.eql(u8, expected_bytes, stdout.?)) { |
| 277 | warn( |
| 278 | \\ |
| 279 | \\========= Expected this stdout: ========= |
| 280 | \\{s} |
| 281 | \\========= But found: ==================== |
| 282 | \\{s} |
| 283 | \\ |
| 284 | , .{ expected_bytes, stdout.? }); |
| 285 | printCmd(cwd, argv); |
| 286 | return error.TestFailed; |
| 287 | } |
| 288 | }, |
| 289 | .expect_matches => |matches| for (matches) |match| { |
| 290 | if (mem.indexOf(u8, stdout.?, match) == null) { |
| 291 | warn( |
| 292 | \\ |
| 293 | \\========= Expected to find in stdout: ========= |
| 294 | \\{s} |
| 295 | \\========= But stdout does not contain it: ===== |
| 296 | \\{s} |
| 297 | \\ |
| 298 | , .{ match, stdout.? }); |
| 299 | printCmd(cwd, argv); |
| 300 | return error.TestFailed; |
| 301 | } |
| 302 | }, |
| 303 | } |
| 304 | } |
| 305 | |
| 306 | fn printCmd(cwd: ?[]const u8, argv: []const []const u8) void { |
| 307 | if (cwd) |yes_cwd| warn("cd {s} && ", .{yes_cwd}); |
| 308 | for (argv) |arg| { |
| 309 | warn("{s} ", .{arg}); |
| 310 | } |
| 311 | warn("\n", .{}); |
| 312 | } |
| 313 | |
| 314 | fn addPathForDynLibs(self: *RunStep, artifact: *LibExeObjStep) void { |
| 315 | for (artifact.link_objects.items) |link_object| { |
| 316 | switch (link_object) { |
| 317 | .other_step => |other| { |
| 318 | if (other.target.isWindows() and other.isDynamicLibrary()) { |
| 319 | self.addPathDir(fs.path.dirname(other.getOutputPath()).?); |
| 320 | self.addPathForDynLibs(other); |
| 321 | } |
| 322 | }, |
| 323 | else => {}, |
| 324 | } |
| 325 | } |
| 326 | } |
| 327 | }; |
Felix "xq" Queißner <xq@random-projects.net> 2021-02-26 19:26:06+01:00
Veikka Tuominen <git@vexu.eu> 2021-06-11 10:43:38+03:00