|
5 | 5 |
|
6 | 6 | use std::net::TcpListener; |
7 | 7 | use std::sync::Arc; |
| 8 | +use std::time::Duration; |
8 | 9 | use tracing::{info, warn}; |
9 | 10 |
|
10 | 11 | use super::app_settings_service::keys; |
@@ -77,6 +78,58 @@ pub fn is_port_available(port: u16) -> bool { |
77 | 78 | TcpListener::bind(("127.0.0.1", port)).is_ok() |
78 | 79 | } |
79 | 80 |
|
| 81 | +/// How long auto-start waits for a busy preferred port to free up before |
| 82 | +/// treating it as a real conflict and deferring to the user. |
| 83 | +/// |
| 84 | +/// Sized to ride out the brief window after an in-place self-update relaunches |
| 85 | +/// the app while the *prior* process is still tearing down its gateway |
| 86 | +/// listener (its graceful shutdown alone can take ~2.5s, and the OS may hold |
| 87 | +/// the socket a moment longer). A genuine conflict — another app permanently |
| 88 | +/// owning the port — stays busy for the whole window and still surfaces the |
| 89 | +/// prompt afterward. |
| 90 | +pub const AUTOSTART_PORT_WAIT: Duration = Duration::from_secs(6); |
| 91 | + |
| 92 | +/// How often [`wait_for_port_available`] re-probes while waiting. |
| 93 | +const PORT_WAIT_PROBE_INTERVAL: Duration = Duration::from_millis(400); |
| 94 | + |
| 95 | +/// Wait up to `timeout` for `port` to become bind-available, re-probing every |
| 96 | +/// [`PORT_WAIT_PROBE_INTERVAL`]. Returns `true` as soon as the port is free, or |
| 97 | +/// `false` if it never frees within the window. |
| 98 | +/// |
| 99 | +/// The common case (port already free) returns immediately with a single |
| 100 | +/// synchronous probe and never sleeps. Only a busy port pays the wait — this |
| 101 | +/// exists for the self-update restart race, where a single probe would see the |
| 102 | +/// port momentarily busy and spuriously raise a conflict even though it frees a |
| 103 | +/// moment later. |
| 104 | +pub async fn wait_for_port_available(port: u16, timeout: Duration) -> bool { |
| 105 | + if is_port_available(port) { |
| 106 | + return true; |
| 107 | + } |
| 108 | + |
| 109 | + info!( |
| 110 | + "[PortService] Port {} busy — waiting up to {:?} for it to free up \ |
| 111 | + (likely a self-update restart racing the prior process's shutdown)", |
| 112 | + port, timeout |
| 113 | + ); |
| 114 | + |
| 115 | + // Track elapsed time by counting fixed-interval sleeps rather than reading |
| 116 | + // a clock — keeps the loop deterministic and trivial to test. |
| 117 | + let mut waited = Duration::ZERO; |
| 118 | + while waited < timeout { |
| 119 | + tokio::time::sleep(PORT_WAIT_PROBE_INTERVAL).await; |
| 120 | + waited = waited.saturating_add(PORT_WAIT_PROBE_INTERVAL); |
| 121 | + if is_port_available(port) { |
| 122 | + info!( |
| 123 | + "[PortService] Port {} became available after ~{:?}", |
| 124 | + port, waited |
| 125 | + ); |
| 126 | + return true; |
| 127 | + } |
| 128 | + } |
| 129 | + |
| 130 | + false |
| 131 | +} |
| 132 | + |
80 | 133 | /// Allocate a dynamic port by letting the OS assign one. |
81 | 134 | pub fn allocate_dynamic_port() -> Result<u16, PortAllocationError> { |
82 | 135 | let listener = TcpListener::bind(("127.0.0.1", 0)) |
@@ -312,6 +365,36 @@ mod tests { |
312 | 365 | assert!(is_port_available(port)); |
313 | 366 | } |
314 | 367 |
|
| 368 | + #[tokio::test] |
| 369 | + async fn test_wait_for_port_available_returns_immediately_when_free() { |
| 370 | + let port = allocate_dynamic_port().unwrap(); |
| 371 | + // Already free — should resolve true without paying the timeout. |
| 372 | + assert!(wait_for_port_available(port, Duration::from_secs(5)).await); |
| 373 | + } |
| 374 | + |
| 375 | + #[tokio::test] |
| 376 | + async fn test_wait_for_port_available_gives_up_when_held() { |
| 377 | + // Hold the port for the whole call so it never frees. |
| 378 | + let held = TcpListener::bind(("127.0.0.1", 0)).unwrap(); |
| 379 | + let port = held.local_addr().unwrap().port(); |
| 380 | + assert!(!is_port_available(port)); |
| 381 | + // Short timeout keeps the test fast; must report the port as unavailable. |
| 382 | + assert!(!wait_for_port_available(port, Duration::from_millis(300)).await); |
| 383 | + } |
| 384 | + |
| 385 | + #[tokio::test] |
| 386 | + async fn test_wait_for_port_available_succeeds_once_freed() { |
| 387 | + // Hold the port, then release it shortly after — mirrors the prior |
| 388 | + // process releasing its listener during a self-update restart. |
| 389 | + let held = TcpListener::bind(("127.0.0.1", 0)).unwrap(); |
| 390 | + let port = held.local_addr().unwrap().port(); |
| 391 | + tokio::spawn(async move { |
| 392 | + tokio::time::sleep(Duration::from_millis(100)).await; |
| 393 | + drop(held); |
| 394 | + }); |
| 395 | + assert!(wait_for_port_available(port, Duration::from_secs(3)).await); |
| 396 | + } |
| 397 | + |
315 | 398 | #[tokio::test] |
316 | 399 | async fn test_service_persistence() { |
317 | 400 | let settings = Arc::new(InMemorySettings::new()); |
|
0 commit comments