接続失敗時のリトライと、バックオフを入れない設計がフリート規模で牙を剥く理由

// src/proxy.rs
pub async fn handle_connection(
    mut inbound: TcpStream,
    peer_addr: SocketAddr,
    lb: Arc<dyn LoadBalancer>,
    backends: Arc<Backends>,
    pools: Arc<Vec<Arc<Pool>>>,
    failure_threshold: usize,
    max_connection_attempts: usize,
) -> std::io::Result<()> {
    let mut last_err = std::io::Error::other("no healthy backend available");

    for _ in 0..max_connection_attempts {
        let Some(backend_addr) = lb.next_backend() else {
            return Err(last_err);
        };

        let idx = backends.index_of(backend_addr);

        let mut outbound = if let Some(stream) = idx.and_then(|idx| pools[idx].try_get()) {
            stream
        } else {
            match TcpStream::connect(backend_addr).await {
                Ok(stream) => {
                    if let Some(idx) = idx {
                        backends.record_success(idx);
                    }
                    stream
                }
                Err(e) => {
                    if let Some(idx) = idx {
                        backends.record_failure(idx, failure_threshold);
                    }
                    lb.release(backend_addr);
                    last_err = e;
                    continue;
                }
            }
        };

        let result = copy_bidirectional(&mut inbound, &mut outbound).await;
        lb.release(backend_addr);

        let (from_client, from_backend) = result?;
        println!(
            "{peer_addr} -> {backend_addr}: {from_client} bytes client->backend, {from_backend} bytes backend->client"
        );
        return Ok(());
    }

    Err(last_err)
}