open-net 0.3.2

A cross-platform async networking library with WebSocket clients and network status monitoring.
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, name: Option<&str>) -> SampleObservation {
    SampleObservation {
        reachability: status,
        network_name: name.map(str::to_owned),
        name_source: NetworkNameSource::NetworkListManager,
        name_diagnostics: vec![],
    }
}

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),
            None,
        )?
        .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, Some("fresh-name")))
    })));
    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_eq!(first.snapshot.network_name.as_deref(), Some("fresh-name"));
    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, Some("late")))
    })));
    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,
            Some("old-generation"),
        ))
    })));
    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, Some("late")))
        },
    )));
    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, Some("dropped")))
        },
    )));
    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, None))
        })));
        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(())
    })
}