slotgate 0.4.2

A bounded-parallelism job runner that gives each slot its own disjoint port range, so port-binding tests run in parallel without collisions.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

// Copyright (c) 2025-2026 Umberto Gotti
// SPDX-License-Identifier: MIT

use crate::config::gate_args::GateArgs;
use crate::config::pre_build_runner::PreBuildRunner;

const LIBTEST_ARGS_FOR_DISCOVERED_BINARY: [&str; 3] = ["{job}", "--exact", "--test-threads=1"];

// The arguments a run should use once the pre-build step has had its say.
//
// This lived on `GateRunner` and is config resolution rather than gate running:
// it reads `PreBuildRunner`, which is in this module already, and hands back
// arguments without executing a single job. Beside `JobSource` it now answers
// the same question that one does -- where does this setting really come from
// -- and `GateRunner` is left orchestrating.
//
// Moving it also bought the headroom the change that prompted it needed.
// `gate_runner.rs` is gated by `iceberg4rust` at a ratchet set just above its
// own score, so any feature added there fails the build by construction, and
// the commit that set the ceiling says to lower it when the score improves and
// never to raise it. Taking twenty-six lines out is that improvement.
pub struct PreBuildResolver;

impl PreBuildResolver {
    /// Without a pre-build program the arguments pass through untouched.
    /// With one, a discovered test binary replaces `program`/`program_args`.
    pub async fn resolve(args: &GateArgs) -> Result<GateArgs, String> {
        let Some(pre_build_program) = &args.pre_build_program else {
            return Ok(args.clone());
        };

        println!(
            "SLOTGATE — PRE-BUILD: {pre_build_program} {}",
            args.pre_build_args.join(" ")
        );
        let discovered = PreBuildRunner::run(
            pre_build_program,
            &args.pre_build_args,
            args.pre_build_target_name.as_deref(),
        )
        .await?;
        println!();

        let Some(executable) = discovered else {
            return Ok(args.clone());
        };

        println!("SLOTGATE — PRE-BUILD discovered test binary: {executable}");
        println!();

        Ok(Self::with_discovered_binary(args, executable))
    }

    fn with_discovered_binary(args: &GateArgs, executable: String) -> GateArgs {
        let mut effective_args = args.clone();
        effective_args.program = executable;
        effective_args.program_args = LIBTEST_ARGS_FOR_DISCOVERED_BINARY
            .iter()
            .map(|arg| String::from(*arg))
            .collect();
        effective_args
    }
}