Struct WaitForConfig 

pub struct WaitForConfig {
    pub http: Option<String>,
    pub tcp: Option<String>,
    pub expect_status: Option<u16>,
    pub timeout_secs: u64,
    pub interval_ms: u64,
}

Step-level config for StepKind::WaitFor (R513-F3, W207 Gap #5). Names a single network endpoint to poll and the time budget for it to come up.

[[steps]]
name = "wait:ready"
kind = "wait-for"
[steps.wait_for]
http = "http://localhost:3000/health"   # plaintext HTTP GET, healthy on 2xx/3xx
timeout_secs = 30                        # give up (and fail the step) after this
# interval_ms = 500                      # poll cadence (default 500ms)
# expect_status = 200                    # require an exact status instead of any 2xx/3xx

Exactly one of Self::http / Self::tcp must be set. The http probe is a dependency-free plaintext HTTP/1.1 GET (no TLS in v1 — an https:// URL is rejected at runtime; use a tcp gate or terminate TLS in front); the tcp probe is a bare connect to host:port, healthy the moment the port accepts. Self::expect_status is HTTP-only.

Fields

http: Option<String>

Plaintext-HTTP URL to GET each poll (e.g. http://localhost:3000/health). Healthy on a 2xx/3xx response, or on an exact match to Self::expect_status when set. Mutually exclusive with Self::tcp.

tcp: Option<String>

host:port to connect to each poll (e.g. 127.0.0.1:5432). Healthy the moment the connect succeeds — no bytes are exchanged. Mutually exclusive with Self::http.

expect_status: Option<u16>

Require this exact HTTP status to consider the endpoint healthy, instead of the default “any 2xx/3xx”. HTTP-only — validate() rejects it alongside a tcp target. None ⇒ any 2xx/3xx.

timeout_secs: u64

Total budget, in seconds, for the endpoint to become healthy. The step fails with a clear “never became healthy” message once this elapses. Defaults to 30s.

interval_ms: u64

Delay between poll attempts, in milliseconds. Defaults to 500ms — snappy enough for a fast-booting dev server without hammering the socket.

Implementations

impl WaitForConfig

pub fn http_is_tls(&self) -> bool

true when an https:// URL was given — TLS health-gates are out of scope for v1 (no HTTP client / TLS stack pulled into qed). The runner surfaces this as a clean StepFailed rather than silently trying a plaintext GET against a TLS port.

Trait Implementations

impl Clone for WaitForConfig

fn clone(&self) -> WaitForConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WaitForConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WaitForConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for WaitForConfig

impl PartialEq for WaitForConfig

fn eq(&self, other: &WaitForConfig) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for WaitForConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for WaitForConfig