reconnect: retry at housekeeping cadence before backing off (match C srtla_send)

README.md

@@ -132,6 +132,9 @@ srtla_send [OPTIONS] SRT_LISTEN_PORT SRTLA_HOST SRTLA_PORT BIND_IPS_FILE
 - `--no-stall-deselect`: Disable the stalled-link deselect guard (on by default). The guard skips a link whose in-flight backlog is high while its last delivery proof (an earned ACK or keepalive round-trip) has gone stale, provided a healthier link can carry the traffic. The link recovers automatically on its next keepalive round-trip, so nothing is probed blindly. This mainly helps satellite links (Starlink obstructions and handovers) that keep a large backlog while briefly delivering nothing.
 - `--stall-min-in-flight <N>`: In-flight backlog (packets) at or above which a link becomes a stall candidate (default 32)
 - `--stall-ack-stale-ms <MS>`: Delivery-proof staleness window in milliseconds after which a stall candidate is deselected (default 3000)
+- `--conn-timeout-ms <MS>`: Per-link liveness timeout; silence past this tears the link down and re-registers it (default 5000, clamped 1000–60000; runtime: `set_conn_timeout`)
+- `--reconnect-fast-retry-ms <MS>`: Reconnect cadence for an uplink that was established and has timed out, during its fast-retry window (default 1000, clamped 1000–5000; runtime: `set_reconnect_fast_retry`). Matches the C reference, which re-opens the socket on every 1 s housekeeping pass, so a short modem/tether blip is re-registered before the SRT session's peer-idle timeout (5 s) ends it
+- `--reconnect-fast-retry-attempts <N>`: Failed reconnects retried at `--reconnect-fast-retry-ms` before the exponential backoff (5 s doubling, 120 s cap) takes over (default 4, max 10). `0` restores the pre-window behaviour: backoff from the first miss
 - `--no-rehome`: Disable whole-bond re-home (on by default). When every uplink has been down for longer than the all-links-failed window *and* the receiver hostname no longer resolves to the address the bond is pinned to, the sender moves every uplink together to the newly-resolved address and re-registers from scratch over the ordinary REG1/REG2/REG3 flow. It is deliberately conservative: a bond with any live uplink is never touched, a merely reordered DNS answer is not a move, a failed lookup is not a move, and at most one migration is attempted per minute. Pass this to keep the old behaviour of staying on the cached address until the process is restarted.
 - `--config <PATH>`: Path to a TOML config file (reloaded on SIGHUP)
 - `--control-socket <PATH>`: Unix domain socket path for remote control (e.g., `/tmp/srtla.sock`)

crates/srtla-core/src/config_snapshot.rs

@@ -109,6 +109,23 @@ pub const CONN_TIMEOUT_MS: u64 = srtla_protocol::CONN_TIMEOUT * 1000;
 pub const CONN_TIMEOUT_MS_MIN: u64 = 1_000;
 pub const CONN_TIMEOUT_MS_MAX: u64 = 60_000;
 
+/// Default reconnect cadence (ms) for an uplink that WAS established and has
+/// timed out, during its fast-retry window. Matches the C reference
+/// (`connection_housekeeping` re-opens the socket on every 1 s pass), so a
+/// short interface blip is re-registered inside the SRT peer-idle timeout.
+pub const RECONNECT_FAST_RETRY_MS: u64 = 1_000;
+/// Clamp bounds for the fast-retry cadence. Housekeeping runs once a second,
+/// so nothing below that is observable; above the exponential ladder's base
+/// (5 s) the "fast" window would be slower than the ladder it precedes.
+pub const RECONNECT_FAST_RETRY_MS_MIN: u64 = 1_000;
+pub const RECONNECT_FAST_RETRY_MS_MAX: u64 = 5_000;
+/// Default number of failed reconnect attempts retried at
+/// [`RECONNECT_FAST_RETRY_MS`] before the exponential backoff ladder
+/// (5 s doubling, 120 s cap) takes over. `0` disables the window: the ladder
+/// applies from the first miss (the previous behaviour).
+pub const RECONNECT_FAST_RETRY_ATTEMPTS: u32 = 4;
+pub const RECONNECT_FAST_RETRY_ATTEMPTS_MAX: u32 = 10;
+
 /// Snapshot of configuration for efficient hot-path access.
 /// Call `DynamicConfig::snapshot()` once per select iteration to avoid
 /// multiple atomic loads per packet in the hot path.
@@ -130,6 +147,13 @@ pub struct ConfigSnapshot {
     /// Per-link liveness timeout in ms (default [`CONN_TIMEOUT_MS`]). Silence
     /// past this tears the link down and re-registers it.
     pub conn_timeout_ms: u64,
+    /// Reconnect cadence (ms) during an established link's fast-retry window
+    /// (default [`RECONNECT_FAST_RETRY_MS`]).
+    pub reconnect_fast_retry_ms: u64,
+    /// Failed reconnect attempts retried at `reconnect_fast_retry_ms` before
+    /// the exponential ladder (default [`RECONNECT_FAST_RETRY_ATTEMPTS`];
+    /// `0` = ladder from the first miss).
+    pub reconnect_fast_retry_attempts: u32,
     /// One-way delivery budget in ms: the TSBPD receive delay the far-end SRT
     /// listener declared in its handshake response, so the deadline a packet on
     /// any link has to beat. Zero until the handshake crosses (and on a peer
@@ -147,6 +171,8 @@ impl Default for ConfigSnapshot {
             stall_min_in_flight: STALL_MIN_IN_FLIGHT_PACKETS,
             stall_ack_stale_ms: STALL_ACK_STALE_MS,
             conn_timeout_ms: CONN_TIMEOUT_MS,
+            reconnect_fast_retry_ms: RECONNECT_FAST_RETRY_MS,
+            reconnect_fast_retry_attempts: RECONNECT_FAST_RETRY_ATTEMPTS,
             negotiated_latency_ms: 0,
         }
     }

crates/srtla-core/src/connection/reconnection.rs

@@ -1,23 +1,50 @@
 use tracing::{debug, info};
 
 use super::STARTUP_GRACE_MS;
+use crate::config_snapshot::{RECONNECT_FAST_RETRY_ATTEMPTS, RECONNECT_FAST_RETRY_MS};
 const BASE_RECONNECT_DELAY_MS: u64 = 5000;
 const MAX_BACKOFF_DELAY_MS: u64 = 120_000;
 const MAX_BACKOFF_COUNT: u32 = 5;
 
 /// Reconnection state and backoff tracking
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct ReconnectionState {
     pub last_reconnect_attempt_ms: u64,
     pub reconnect_failure_count: u32,
     pub connection_established_ms: u64,
     pub startup_grace_deadline_ms: u64,
+    /// Fast-retry window for a link that WAS established (see
+    /// [`RECONNECT_FAST_RETRY_MS`]). Refreshed from the runtime
+    /// `ConfigSnapshot` alongside `conn_timeout_ms`.
+    pub fast_retry_ms: u64,
+    pub fast_retry_attempts: u32,
+}
+
+impl Default for ReconnectionState {
+    fn default() -> Self {
+        Self {
+            last_reconnect_attempt_ms: 0,
+            reconnect_failure_count: 0,
+            connection_established_ms: 0,
+            startup_grace_deadline_ms: 0,
+            fast_retry_ms: RECONNECT_FAST_RETRY_MS,
+            fast_retry_attempts: RECONNECT_FAST_RETRY_ATTEMPTS,
+        }
+    }
 }
 
 impl ReconnectionState {
-    /// Calculate backoff delay based on failure count.
+    /// Calculate backoff delay based on failure count: `fast_retry_ms` for the
+    /// first `fast_retry_attempts` failures (matching the C reference, which
+    /// re-opens the socket on every housekeeping pass), then exponential from
+    /// `BASE_RECONNECT_DELAY_MS`, capped at `MAX_BACKOFF_DELAY_MS`. With
+    /// `fast_retry_attempts == 0` this is the plain ladder.
     fn backoff_delay(&self) -> u64 {
-        let capped_failures = self.reconnect_failure_count.min(MAX_BACKOFF_COUNT);
+        if self.reconnect_failure_count < self.fast_retry_attempts {
+            return self.fast_retry_ms;
+        }
+        let capped_failures =
+            (self.reconnect_failure_count - self.fast_retry_attempts).min(MAX_BACKOFF_COUNT);
         let delay = BASE_RECONNECT_DELAY_MS.saturating_mul(1u64 << capped_failures);
         delay.min(MAX_BACKOFF_DELAY_MS)
     }
@@ -58,10 +85,10 @@ impl ReconnectionState {
         self.reconnect_failure_count = self.reconnect_failure_count.saturating_add(1);
 
         info!(
-            "{}: Reconnect attempt #{}, next attempt in {}s",
+            "{}: Reconnect attempt #{}, next attempt in {}ms",
             label,
             self.reconnect_failure_count,
-            self.backoff_delay() / 1000
+            self.backoff_delay()
         );
     }
 
@@ -76,3 +103,144 @@ impl ReconnectionState {
         self.startup_grace_deadline_ms = now + STARTUP_GRACE_MS;
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A link that was established (REG3 seen) and has just timed out.
+    fn established() -> ReconnectionState {
+        ReconnectionState {
+            connection_established_ms: 1_000,
+            ..Default::default()
+        }
+    }
+
+    fn established_with(fast_retry_ms: u64, fast_retry_attempts: u32) -> ReconnectionState {
+        ReconnectionState {
+            fast_retry_ms,
+            fast_retry_attempts,
+            ..established()
+        }
+    }
+
+    /// Record an attempt at `t` and return the delay until the next one is
+    /// allowed, asserting the boundary is exact.
+    fn wait_after_attempt(state: &mut ReconnectionState, t: u64) -> u64 {
+        state.record_attempt("test", t);
+        let mut wait = 1;
+        while !state.should_attempt_reconnect(t + wait) {
+            wait += 1;
+            assert!(wait <= MAX_BACKOFF_DELAY_MS, "never allowed a retry");
+        }
+        assert!(!state.should_attempt_reconnect(t + wait - 1));
+        wait
+    }
+
+    /// The waits between the first `n` consecutive failed attempts.
+    fn schedule(mut state: ReconnectionState, n: usize) -> Vec<u64> {
+        let mut t = 50_000;
+        let mut waits = Vec::new();
+        for _ in 0..n {
+            let w = wait_after_attempt(&mut state, t);
+            waits.push(w);
+            t += w;
+        }
+        waits
+    }
+
+    /// The schedule before the fast-retry window existed: `5000 << n`, capped.
+    const LADDER: [u64; 8] = [
+        10_000, 20_000, 40_000, 80_000, 120_000, 120_000, 120_000, 120_000,
+    ];
+
+    #[test]
+    fn defaults_are_one_second_for_four_attempts() {
+        let state = ReconnectionState::default();
+        assert_eq!(state.fast_retry_ms, 1000);
+        assert_eq!(state.fast_retry_attempts, 4);
+    }
+
+    #[test]
+    fn established_link_retries_after_one_second() {
+        let mut state = established();
+        let t = 50_000;
+        assert!(state.should_attempt_reconnect(t));
+        state.record_attempt("test", t);
+        assert!(!state.should_attempt_reconnect(t + 999));
+        assert!(state.should_attempt_reconnect(t + 1000));
+    }
+
+    #[test]
+    fn fast_window_then_exponential_ladder() {
+        // Attempts 1-3 wait 1 s; the 4th recorded failure starts the ladder, so
+        // the wait before the 5th attempt is 5 s, then it doubles to the cap.
+        assert_eq!(
+            schedule(established(), 11),
+            vec![
+                1000, 1000, 1000, 5000, 10_000, 20_000, 40_000, 80_000, 120_000, 120_000, 120_000
+            ]
+        );
+    }
+
+    #[test]
+    fn fifth_attempt_waits_five_seconds() {
+        let mut state = established();
+        let mut t = 50_000;
+        for _ in 0..3 {
+            state.record_attempt("test", t);
+            t += 1000;
+            assert!(state.should_attempt_reconnect(t));
+        }
+        state.record_attempt("test", t);
+        assert_eq!(state.reconnect_failure_count, 4);
+        assert!(!state.should_attempt_reconnect(t + 4999));
+        assert!(state.should_attempt_reconnect(t + 5000));
+    }
+
+    #[test]
+    fn zero_attempts_is_the_plain_ladder() {
+        // Opt-out: with no fast-retry window the schedule is exactly the
+        // pre-existing `5000 << failure_count` ladder.
+        assert_eq!(schedule(established_with(1000, 0), 8), LADDER.to_vec());
+        assert_eq!(
+            schedule(established_with(3000, 0), 8),
+            LADDER.to_vec(),
+            "the fast cadence must be irrelevant when the window is empty"
+        );
+    }
+
+    #[test]
+    fn window_is_configurable() {
+        assert_eq!(
+            schedule(established_with(2000, 2), 5),
+            vec![2000, 5000, 10_000, 20_000, 40_000]
+        );
+    }
+
+    #[test]
+    fn success_resets_to_fast_retry() {
+        let mut state = established();
+        for i in 0..6 {
+            state.record_attempt("test", 50_000 + i);
+        }
+        state.mark_success("test");
+        assert_eq!(wait_after_attempt(&mut state, 200_000), 1000);
+    }
+
+    #[test]
+    fn initial_registration_cadence_unchanged() {
+        let mut state = ReconnectionState {
+            startup_grace_deadline_ms: 10_000,
+            fast_retry_ms: 5000,
+            fast_retry_attempts: 0,
+            ..Default::default()
+        };
+        assert!(!state.should_attempt_reconnect(10_000));
+        assert!(state.should_attempt_reconnect(10_001));
+        state.record_attempt("test", 10_001);
+        assert_eq!(state.reconnect_failure_count, 0);
+        assert!(!state.should_attempt_reconnect(11_000));
+        assert!(state.should_attempt_reconnect(11_001));
+    }
+}

crates/srtla-core/src/selection/mod.rs

@@ -103,14 +103,16 @@ pub fn select_connection_idx(
 /// flag, latch, and pull are all cleared, restoring byte-for-byte baseline
 /// selection.
 ///
-/// Also refreshes each link's `conn_timeout_ms` and `delay_budget_ms` from the
-/// snapshot, so the runtime-tunable liveness window and the peer's declared
+/// Also refreshes each link's `conn_timeout_ms`, reconnect fast-retry window
+/// and `delay_budget_ms` from the snapshot, so the runtime-tunable liveness window and the peer's declared
 /// receive buffer reach `is_timed_out` and `update_stall_latch` callers that do
 /// not carry a config.
 #[inline]
 fn apply_stall_gate(conns: &mut [SrtlaConnection], current_time_ms: u64, config: &ConfigSnapshot) {
     for c in conns.iter_mut() {
         c.conn_timeout_ms = config.conn_timeout_ms;
+        c.reconnection.fast_retry_ms = config.reconnect_fast_retry_ms;
+        c.reconnection.fast_retry_attempts = config.reconnect_fast_retry_attempts;
         c.delay_budget_ms = config.negotiated_latency_ms;
     }