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::super::shared::SharedNetworkService;
use super::*;
use crate::common::CommonEngine;
use crate::net_status::{MonitorState, NetworkEventKind, NetworkEventOptions};
use std::sync::atomic::AtomicUsize;

type TestResult = Result<(), Box<dyn std::error::Error + Send + Sync>>;

fn observation(status: NetworkStatus) -> SampleObservation {
    SampleObservation {
        reachability: status,
    }
}

async fn running() -> Result<(Arc<SharedNetworkService>, Arc<NetworkObservationOwner>), NetError> {
    let service = SharedNetworkService::new(Arc::new(CommonEngine::new(16, 16)?))?;
    let owner = NetworkObservationOwner::new(service.context())?;
    let (publisher, initial) = service.context().observation_source()?.begin_generation()?;
    initial.dispatch()?;
    publisher
        .prepare_observation(
            NetworkStatus::Available,
            Some(crate::net_status::IpStack::DualStack),
        )?
        .dispatch()?;
    owner.activate_view_for_test()?;
    Ok((service, owner))
}

#[cfg(test)]
#[tokio::test]
async fn refresh_commits_once_and_same_value_has_new_sampling_evidence() -> TestResult {
    let (service, owner) = running().await?;
    let mut events = owner.subscribe_events(NetworkEventOptions::default())?;
    let _ = events.recv().await?;
    let calls = Arc::new(AtomicUsize::new(0));
    let counted = calls.clone();
    let status = match owner.snapshot()?.reachability {
        Some(NetworkStatus::Available) => NetworkStatus::Unavailable,
        _ => NetworkStatus::Available,
    };
    let sampler = Arc::new(WindowsSampler::with_provider(Arc::new(move |_, _| {
        counted.fetch_add(1, Ordering::SeqCst);
        Ok(observation(status))
    })));
    let first = refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        sampler.clone(),
        deadline(Duration::from_secs(5))?,
    )
    .await?;
    assert_eq!(first.snapshot.reachability, Some(status));
    assert!(first.snapshot.network_name.is_none());
    assert_eq!(first.network_name_source, NetworkNameSource::NotCollected);
    assert!(first.network_name_diagnostics.is_empty());
    assert_eq!(owner.snapshot()?.revision, first.snapshot.revision);
    assert!(matches!(
        events.recv().await?.ok_or("missing changed event")?.kind,
        NetworkEventKind::ReachabilityChanged { .. }
    ));
    let second = refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        sampler,
        deadline(Duration::from_secs(5))?,
    )
    .await?;
    assert_eq!(calls.load(Ordering::SeqCst), 2);
    assert!(second.sample_id > first.sample_id);
    assert_eq!(second.snapshot.revision, first.snapshot.revision);
    assert_eq!(second.snapshot.observed_at, first.snapshot.observed_at);
    assert!(matches!(
        events.try_recv(),
        Err(crate::error::TryReceiveError::Empty)
    ));
    service.shutdown().await?;
    Ok(())
}

#[cfg(test)]
#[tokio::test]
async fn request_failure_is_not_an_unavailable_observation() -> TestResult {
    let (service, owner) = running().await?;
    let before = owner.snapshot()?;
    let sampler = Arc::new(WindowsSampler::with_provider(Arc::new(|_, _| {
        Err(error(ErrorKind::Io))
    })));
    let failed = refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        sampler,
        deadline(Duration::from_secs(5))?,
    )
    .await;
    assert_eq!(
        failed.err().ok_or("query unexpectedly succeeded")?.kind(),
        ErrorKind::Io
    );
    assert_eq!(owner.snapshot()?.revision, before.revision);
    assert!(matches!(owner.snapshot()?.state, MonitorState::Running));
    service.shutdown().await?;
    Ok(())
}

#[cfg(test)]
#[tokio::test]
async fn timed_out_native_work_cannot_publish_and_queue_deadline_prevents_sampling() -> TestResult {
    let (service, owner) = running().await?;
    let before = owner.snapshot()?;
    let (entered, entered_rx) = tokio::sync::oneshot::channel();
    let entered = std::sync::Mutex::new(Some(entered));
    let (release, released) = mpsc::channel();
    let released = std::sync::Mutex::new(released);
    let calls = Arc::new(AtomicUsize::new(0));
    let count = calls.clone();
    let sampler = Arc::new(WindowsSampler::with_provider(Arc::new(move |_, _| {
        count.fetch_add(1, Ordering::SeqCst);
        if let Some(entered) = entered.lock().map_err(NetError::from_poison)?.take() {
            let _ = entered.send(());
        }
        released
            .lock()
            .map_err(NetError::from_poison)?
            .recv()
            .map_err(|_| error(ErrorKind::Internal))?;
        Ok(observation(NetworkStatus::Unavailable))
    })));
    let future = refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        sampler.clone(),
        deadline(Duration::from_millis(50))?,
    );
    let first = tokio::spawn(future);
    entered_rx.await?;
    let second = refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        sampler,
        deadline(Duration::from_millis(20))?,
    )
    .await;
    assert_eq!(
        second.err().ok_or("queued request succeeded")?.kind(),
        ErrorKind::TimedOut
    );
    assert_eq!(
        first.await?.err().ok_or("late request succeeded")?.kind(),
        ErrorKind::TimedOut
    );
    release.send(())?;
    assert_eq!(owner.snapshot()?.revision, before.revision);
    assert_eq!(calls.load(Ordering::SeqCst), 1);
    service.shutdown().await?;
    Ok(())
}

#[cfg(test)]
#[tokio::test]
async fn stop_of_one_view_revokes_only_its_refresh_eligibility() -> TestResult {
    let (service, owner) = running().await?;
    let other = NetworkObservationOwner::new(service.context())?;
    other.activate_view_for_test()?;
    let target = owner.refresh_target()?;
    owner.request_stop()?;
    owner.wait_cleanup().await?;
    assert_eq!(
        owner
            .refresh_target()
            .err()
            .ok_or("stopped view accepted refresh")?
            .kind(),
        ErrorKind::NotRunning
    );
    assert!(other.refresh_target().is_ok());
    owner.activate_view_for_test()?;
    let before = owner.snapshot()?;
    let sampler = Arc::new(WindowsSampler::with_provider(Arc::new(|_, _| {
        Ok(observation(NetworkStatus::Unavailable))
    })));
    let result = refresh_with_sampler(
        owner.clone(),
        target,
        sampler,
        deadline(Duration::from_secs(5))?,
    )
    .await;
    assert_eq!(
        result
            .err()
            .ok_or("old-generation request succeeded")?
            .kind(),
        ErrorKind::Cancelled
    );
    assert_eq!(owner.snapshot()?.revision, before.revision);
    service.shutdown().await?;
    Ok(())
}

#[cfg(test)]
#[test]
fn invalid_deadlines_are_classified() {
    assert_eq!(
        deadline(Duration::ZERO).err().map(|e| e.kind()),
        Some(ErrorKind::InvalidInput)
    );
    assert_eq!(
        deadline(Duration::MAX).err().map(|e| e.kind()),
        Some(ErrorKind::InvalidInput)
    );
}

#[cfg(test)]
#[tokio::test]
async fn stop_interrupts_refresh_without_waiting_for_native_return() -> TestResult {
    let (service, owner) = running().await?;
    let (entered, started) = tokio::sync::oneshot::channel();
    let entered = std::sync::Mutex::new(Some(entered));
    let (release, blocked) = mpsc::channel();
    let blocked = std::sync::Mutex::new(blocked);
    let sampler = Arc::new(WindowsSampler::with_provider(Arc::new(
        move |_, cancelled| {
            if let Some(sender) = entered.lock().map_err(NetError::from_poison)?.take() {
                let _ = sender.send(());
            }
            blocked
                .lock()
                .map_err(NetError::from_poison)?
                .recv()
                .map_err(|_| error(ErrorKind::Internal))?;
            assert!(cancelled.load(Ordering::Acquire));
            Ok(observation(NetworkStatus::Unavailable))
        },
    )));
    let refresh = tokio::spawn(refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        sampler,
        deadline(Duration::from_secs(30))?,
    ));
    started.await?;
    owner.request_stop()?;
    let result = tokio::time::timeout(Duration::from_secs(2), refresh).await??;
    let _ = release.send(());
    assert_eq!(
        result.err().ok_or("stopped request committed")?.kind(),
        ErrorKind::Cancelled
    );
    assert!(matches!(owner.snapshot()?.state, MonitorState::Stopped));
    service.shutdown().await?;
    Ok(())
}

#[cfg(test)]
#[tokio::test]
async fn dropping_refresh_future_revokes_late_commit() -> TestResult {
    let (service, owner) = running().await?;
    let before = owner.snapshot()?;
    let (entered, started) = tokio::sync::oneshot::channel();
    let entered = std::sync::Mutex::new(Some(entered));
    let (released, blocked) = mpsc::channel();
    let blocked = std::sync::Mutex::new(blocked);
    let (completed, finished) = tokio::sync::oneshot::channel();
    let completed = std::sync::Mutex::new(Some(completed));
    let sampler = Arc::new(WindowsSampler::with_provider(Arc::new(
        move |_, cancelled| {
            if let Some(sender) = entered.lock().map_err(NetError::from_poison)?.take() {
                let _ = sender.send(());
            }
            blocked
                .lock()
                .map_err(NetError::from_poison)?
                .recv()
                .map_err(|_| error(ErrorKind::Internal))?;
            let invalid = cancelled.load(Ordering::Acquire);
            if let Some(sender) = completed.lock().map_err(NetError::from_poison)?.take() {
                let _ = sender.send(invalid);
            }
            Ok(observation(NetworkStatus::Unavailable))
        },
    )));
    let refresh = tokio::spawn(refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        sampler,
        deadline(Duration::from_secs(30))?,
    ));
    started.await?;
    refresh.abort();
    assert!(refresh.await.is_err());
    released.send(())?;
    assert!(tokio::time::timeout(Duration::from_secs(2), finished).await??);
    assert_eq!(owner.snapshot()?.revision, before.revision);
    service.shutdown().await?;
    Ok(())
}

#[cfg(not(target_os = "windows"))]
#[cfg(test)]
#[tokio::test]
async fn unsupported_platform_does_not_pretend_cache_is_fresh() -> TestResult {
    let (service, owner) = running().await?;
    let before = owner.snapshot()?;
    assert_eq!(
        refresh_reachability(owner.clone(), Duration::from_secs(1))
            .await
            .err()
            .ok_or("unsupported reachability refresh succeeded")?
            .kind(),
        ErrorKind::Unsupported
    );
    assert_eq!(
        refresh(owner.clone(), Duration::from_secs(1))
            .await
            .err()
            .ok_or("unsupported refresh succeeded")?
            .kind(),
        ErrorKind::Unsupported
    );
    assert_eq!(owner.snapshot()?.revision, before.revision);
    owner.request_stop()?;
    assert_eq!(
        refresh(owner.clone(), Duration::from_secs(1))
            .await
            .err()
            .ok_or("stopped refresh succeeded")?
            .kind(),
        ErrorKind::NotRunning
    );
    service.shutdown().await?;
    Ok(())
}

#[cfg(test)]
#[test]
fn refresh_can_be_polled_without_a_caller_tokio_runtime() -> TestResult {
    futures::executor::block_on(async {
        let (service, owner) = running().await?;
        let sampler = Arc::new(WindowsSampler::with_provider(Arc::new(|_, _| {
            Ok(observation(NetworkStatus::Available))
        })));
        let result = refresh_with_sampler(
            owner.clone(),
            owner.refresh_target()?,
            sampler,
            deadline(Duration::from_secs(2))?,
        )
        .await?;
        assert_eq!(result.snapshot.revision, owner.snapshot()?.revision);
        service.shutdown().await?;
        Ok(())
    })
}