open-net 0.3.5

A cross-platform async networking library for Rust with HTTP and WebSocket clients, network status monitoring, configurable retries, WebSocket reconnection and heartbeats, and managed client lifecycles. Reuse common networking infrastructure across applications to avoid repeated implementation and debugging, helping save development time and AI coding tokens.
Documentation
use super::tests::journal;
use super::*;
use crate::module::transport::failure::ConnectStage;
use crate::module::ws_client::test_support::{check, check_eq, TestResult};
use std::time::Duration;

#[tokio::test]
async fn lifecycle_logs_follow_commits_and_bound_retries_without_sensitive_fields() -> TestResult {
    let (tx, rx) = std::sync::mpsc::channel();
    let _subscription = crate::OpenNetLogger::register_log_listener(
        Box::new(move |record| {
            if record.tag.starts_with("ws.") && record.content.contains("97101") {
                let _ = tx.send(record);
            }
        }),
        &[crate::LogType::WSC],
    )?;
    let metadata = Arc::new(crate::Metadata::from([(
        "name".to_owned(),
        "SECRET_metadata".to_owned(),
    )]));
    let (session, _events) =
        ConnectionSession::journal_fixture_with_metadata(97_101, 97_102, journal(32), metadata)?;
    let failure = || {
        ConnectionFailure::new(
            NetError::with_source(ErrorKind::Io, std::io::Error::other("SECRET_source")),
            ConnectStage::Tcp,
            None,
            true,
        )
    };
    for attempt in 0..5 {
        session.begin_attempt(
            session.handshake_attempt(1, attempt),
            session.reserve_attempt().await?,
        )?;
        session.attempt_failed(
            1,
            attempt,
            failure(),
            RetryDecision::Scheduled {
                after: Duration::from_millis(1),
            },
        )?;
    }
    session.begin_attempt(
        session.handshake_attempt(1, 5),
        session.reserve_attempt().await?,
    )?;
    check!(session.commit_established(1, 5).is_err())?;
    session.set_attempt_credential_version(1, 5, Some("SECRET_credential".to_owned()))?;
    session.established(1, 5)?;
    check!(session.commit_established(1, 5).is_err())?;
    session.connection_terminated_with_details(
        TerminationReason::IoFailure,
        Some(failure()),
        ConnectionTerminationDetails {
            peer_close: Some(crate::ws::PeerClose {
                code: Some(1000),
                reason: "SECRET_close".to_owned(),
            }),
            ..Default::default()
        },
        Some(2),
    )?;
    session.begin_cycle(2, true)?;
    session.begin_attempt(
        session.handshake_attempt(2, 0),
        session.reserve_attempt().await?,
    )?;
    session.attempt_failed(2, 0, failure(), RetryDecision::Stop)?;
    session.terminate(TerminationReason::RetryExhausted, None)?;
    session.terminate(TerminationReason::RetryExhausted, None)?;
    crate::log_s!(crate::LogType::WSC, crate::LogLevel::Key; "ws.lifecycle.lifecycle_logs_follow_commits_and_bound_retries_without_sensitive_fields", "client_id", 97_101);
    let mut records = Vec::new();
    loop {
        let record = rx.recv_timeout(Duration::from_secs(3))?;
        if record.tag == "ws.lifecycle.lifecycle_logs_follow_commits_and_bound_retries_without_sensitive_fields" {
            break;
        }
        check_eq!(record.tag.as_str(), "ws.connection_session.emit")?;
        check_eq!(record.level, crate::LogLevel::Key)?;
        check!(!record.content.contains("SECRET_"))?;
        records.push(record);
    }
    let fields = records
        .iter()
        .map(|record| serde_json::from_str::<serde_json::Value>(&record.content))
        .collect::<std::result::Result<Vec<_>, _>>()?;
    check_eq!(
        fields
            .iter()
            .map(|fields| fields["event"].as_str().unwrap_or_default())
            .collect::<Vec<_>>(),
        vec![
            "ws.reconnect.started",
            "ws.connection.established",
            "ws.connection.disconnected",
            "ws.reconnect.started",
            "ws.session.closed",
        ]
    )?;
    let established = &fields[1];
    // The initial failed connect starts the episode; only the five attempts
    // admitted after that transition count as reconnect attempts.
    check_eq!(established["reconnect_attempts"].as_u64(), Some(5))?;
    check_eq!(established["last_reconnect_stage"].as_str(), Some("Tcp"))?;
    let closed = &fields[4];
    check_eq!(closed["error_kind"].as_str(), Some("RetryExhausted"))?;
    check_eq!(closed["last_reconnect_kind"].as_str(), Some("Io"))?;
    check_eq!(closed["reconnect_attempts"].as_u64(), Some(1))?;
    check_eq!(
        session
            .terminal_result_checked()?
            .ok_or("terminal result")?
            .err()
            .ok_or("expected terminal failure")?
            .kind(),
        ErrorKind::RetryExhausted
    )?;
    Ok(())
}

#[tokio::test]
async fn cancelled_preparation_and_repeated_termination_do_not_log_established() -> TestResult {
    let (tx, rx) = std::sync::mpsc::channel();
    let _subscription = crate::OpenNetLogger::register_log_listener(
        Box::new(move |record| {
            if record.tag.starts_with("ws.") && record.content.contains("97103") {
                let _ = tx.send(record);
            }
        }),
        &[crate::LogType::WSC],
    )?;
    let (session, _events) = ConnectionSession::journal_fixture(97_103, 97_104, journal(4))?;
    session.begin_attempt(
        session.handshake_attempt(1, 0),
        session.reserve_attempt().await?,
    )?;
    session.set_attempt_credential_version(1, 0, None)?;
    check!(session.request_cancel())?;
    check!(session.prepare_established(1, 0).is_err())?;
    session.terminate(TerminationReason::Cancelled, None)?;
    session.terminate(TerminationReason::Cancelled, None)?;
    crate::log_s!(crate::LogType::WSC, crate::LogLevel::Key; "ws.lifecycle.cancelled_preparation_and_repeated_termination_do_not_log_established", "client_id", 97_103);
    let record = rx.recv_timeout(Duration::from_secs(3))?;
    check_eq!(record.tag.as_str(), "ws.connection_session.emit")?;
    let fields: serde_json::Value = serde_json::from_str(&record.content)?;
    check_eq!(fields["event"].as_str(), Some("ws.session.closed"))?;
    check_eq!(
        rx.recv_timeout(Duration::from_secs(3))?.tag.as_str(),
        "ws.lifecycle.cancelled_preparation_and_repeated_termination_do_not_log_established"
    )?;
    Ok(())
}