open-net 0.3.2

A cross-platform async networking library with WebSocket clients and network status monitoring.
Documentation
use super::super::network_status_snapshot::{NetworkNameUpdate, NetworkStatusPublisher};
use super::super::shared::SharedNetworkService;
use super::*;
use crate::common::CommonEngine;
use crate::net_status::{IpStack, MonitorState};
use std::sync::Mutex;

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

async fn running() -> Result<
    (
        Arc<SharedNetworkService>,
        Arc<NetworkObservationOwner>,
        NetworkStatusPublisher,
    ),
    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(IpStack::DualStack),
            Some("initial".into()),
        )?
        .dispatch()?;
    owner.activate_view_for_test()?;
    Ok((service, owner, publisher))
}

fn reachability(status: NetworkStatus) -> SampleObservation {
    SampleObservation {
        reachability: status,
        network_name: None,
        name_source: NetworkNameSource::CachedObservation,
        name_diagnostics: Vec::new(),
    }
}

fn full(status: NetworkStatus, name: &str) -> SampleObservation {
    SampleObservation {
        reachability: status,
        network_name: Some(name.into()),
        name_source: NetworkNameSource::NetworkListManager,
        name_diagnostics: Vec::new(),
    }
}

#[cfg(test)]
#[tokio::test]
async fn name_failure_does_not_prevent_a_fresh_reachability_commit() -> TestResult {
    let (service, owner, _) = running().await?;
    let counter = Arc::new(AtomicU64::new(0));
    let names = Arc::new(WindowsSampler::with_counter(
        Arc::new(|_, _| Err(error(ErrorKind::Io))),
        counter.clone(),
    ));
    let status = Arc::new(WindowsSampler::with_counter(
        Arc::new(|_, _| Ok(reachability(NetworkStatus::Unavailable))),
        counter,
    ));
    let failed = refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        names,
        deadline(Duration::from_secs(2))?,
    )
    .await;
    assert_eq!(
        failed.err().ok_or("name query should fail")?.kind(),
        ErrorKind::Io
    );
    assert!(matches!(owner.snapshot()?.state, MonitorState::Running));
    let fresh = refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        status,
        deadline(Duration::from_secs(2))?,
    )
    .await?;
    assert_eq!(
        fresh.snapshot.reachability,
        Some(NetworkStatus::Unavailable)
    );
    assert_eq!(fresh.snapshot.network_name.as_deref(), Some("initial"));
    assert_eq!(
        fresh.network_name_source,
        NetworkNameSource::CachedObservation
    );
    service.shutdown().await?;
    Ok(())
}

#[cfg(test)]
#[tokio::test]
async fn blocked_name_lane_cannot_delay_status_and_timed_out_names_cannot_publish() -> TestResult {
    let (service, owner, _) = running().await?;
    let counter = Arc::new(AtomicU64::new(0));
    let (entered, started) = tokio::sync::oneshot::channel();
    let entered = Mutex::new(Some(entered));
    let (release, released) = mpsc::channel();
    let released = Mutex::new(released);
    let (finished, completed) = tokio::sync::oneshot::channel();
    let finished = Mutex::new(Some(finished));
    let names = Arc::new(WindowsSampler::with_counter(
        Arc::new(move |_, cancelled| {
            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))?;
            if let Some(finished) = finished.lock().map_err(NetError::from_poison)?.take() {
                let _ = finished.send(cancelled.load(Ordering::Acquire));
            }
            Ok(full(NetworkStatus::Available, "too-late"))
        }),
        counter.clone(),
    ));
    let status = Arc::new(WindowsSampler::with_counter(
        Arc::new(|_, _| Ok(reachability(NetworkStatus::Unavailable))),
        counter,
    ));
    let pending_name = tokio::spawn(refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        names,
        deadline(Duration::from_millis(100))?,
    ));
    started.await?;
    let fresh = refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        status,
        deadline(Duration::from_secs(2))?,
    )
    .await?;
    assert_eq!(
        fresh.snapshot.reachability,
        Some(NetworkStatus::Unavailable)
    );
    assert_eq!(
        pending_name
            .await?
            .err()
            .ok_or("name query should time out")?
            .kind(),
        ErrorKind::TimedOut
    );
    release.send(())?;
    assert!(completed.await?);
    assert_eq!(owner.snapshot()?.network_name.as_deref(), Some("initial"));
    assert_eq!(
        owner.snapshot()?.reachability,
        Some(NetworkStatus::Unavailable)
    );
    service.shutdown().await?;
    Ok(())
}

#[cfg(test)]
#[tokio::test]
async fn slow_background_name_updates_without_rolling_back_newer_reachability() -> TestResult {
    let (service, owner, publisher) = running().await?;
    let counter = Arc::new(AtomicU64::new(0));
    let (entered, started) = tokio::sync::oneshot::channel();
    let entered = Mutex::new(Some(entered));
    let (release, released) = mpsc::channel();
    let released = Mutex::new(released);
    let names = Arc::new(WindowsSampler::with_counter(
        Arc::new(move |_, _| {
            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(full(NetworkStatus::Available, "new-name"))
        }),
        counter.clone(),
    ));
    let status = Arc::new(WindowsSampler::with_counter(
        Arc::new(|_, _| Ok(reachability(NetworkStatus::Unavailable))),
        counter,
    ));
    let pending_name = tokio::spawn(async move {
        names
            .sample(
                deadline(Duration::from_secs(5))?,
                Arc::new(AtomicBool::new(false)),
            )
            .await
    });
    started.await?;
    let fresh = refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        status,
        deadline(Duration::from_secs(2))?,
    )
    .await?;
    release.send(())?;
    let named = pending_name.await??;
    assert!(named.id < fresh.sample_id);
    publisher
        .prepare_sampled_name_observation(
            named.id,
            named.observation.network_name,
            named.sampled_at,
            || Ok(true),
        )?
        .ok_or("fresh name was rejected")?
        .dispatch()?;
    let snapshot = owner.snapshot()?;
    assert_eq!(snapshot.reachability, Some(NetworkStatus::Unavailable));
    assert_eq!(snapshot.network_name.as_deref(), Some("new-name"));
    service.shutdown().await?;
    Ok(())
}

#[cfg(test)]
#[tokio::test]
async fn slow_full_refresh_keeps_its_fresh_name_and_later_reachability() -> TestResult {
    let (service, owner, _) = running().await?;
    let counter = Arc::new(AtomicU64::new(0));
    let (entered, started) = tokio::sync::oneshot::channel();
    let entered = Mutex::new(Some(entered));
    let (release, released) = mpsc::channel();
    let released = Mutex::new(released);
    let names = Arc::new(WindowsSampler::with_counter(
        Arc::new(move |_, _| {
            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(full(NetworkStatus::Available, "fresh-name"))
        }),
        counter.clone(),
    ));
    let status = Arc::new(WindowsSampler::with_counter(
        Arc::new(|_, _| Ok(reachability(NetworkStatus::Unavailable))),
        counter,
    ));
    let pending_name = tokio::spawn(refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        names,
        deadline(Duration::from_secs(5))?,
    ));
    started.await?;
    for _ in 0..2 {
        let fresh = refresh_with_sampler(
            owner.clone(),
            owner.refresh_target()?,
            status.clone(),
            deadline(Duration::from_secs(2))?,
        )
        .await?;
        assert_eq!(
            fresh.snapshot.reachability,
            Some(NetworkStatus::Unavailable)
        );
    }
    release.send(())?;
    let named = pending_name.await??;
    assert_eq!(named.snapshot.network_name.as_deref(), Some("fresh-name"));
    assert_eq!(
        named.snapshot.reachability,
        Some(NetworkStatus::Unavailable)
    );
    assert_eq!(named.sampled_reachability, NetworkStatus::Available);
    assert_eq!(
        named.network_name_source,
        NetworkNameSource::NetworkListManager
    );
    service.shutdown().await?;
    Ok(())
}

#[cfg(test)]
#[tokio::test]
async fn reachability_preserves_name_at_commit_and_full_metadata_never_labels_stale_fields(
) -> TestResult {
    let (service, owner, publisher) = running().await?;
    publisher
        .prepare_sampled_name_observation(3, Some("newest-name".into()), SystemTime::now(), || {
            Ok(true)
        })?
        .ok_or("name update rejected")?
        .dispatch()?;
    let snapshot = owner.commit_refresh(
        owner.refresh_target()?,
        2,
        NetworkStatus::Unavailable,
        None,
        NetworkNameUpdate::Preserve,
        SystemTime::now(),
        || Ok(()),
    )?;
    assert_eq!(snapshot.reachability, Some(NetworkStatus::Unavailable));
    assert_eq!(snapshot.network_name.as_deref(), Some("newest-name"));
    let stale_full = owner.commit_refresh(
        owner.refresh_target()?,
        3,
        NetworkStatus::Available,
        None,
        Some("stale-name".into()),
        SystemTime::now(),
        || Ok(()),
    );
    assert_eq!(
        stale_full
            .err()
            .ok_or("stale name got fresh metadata")?
            .kind(),
        ErrorKind::Cancelled
    );
    service.shutdown().await?;
    Ok(())
}

#[cfg(test)]
#[tokio::test]
async fn both_lanes_share_checked_sample_identifiers() -> TestResult {
    let counter = Arc::new(AtomicU64::new(u64::MAX - 1));
    let first = WindowsSampler::with_counter(
        Arc::new(|_, _| Ok(reachability(NetworkStatus::Available))),
        counter.clone(),
    );
    let second = WindowsSampler::with_counter(
        Arc::new(|_, _| Ok(full(NetworkStatus::Available, "name"))),
        counter,
    );
    let sampled = first
        .sample(
            deadline(Duration::from_secs(2))?,
            Arc::new(AtomicBool::new(false)),
        )
        .await?;
    assert_eq!(sampled.id, u64::MAX);
    let exhausted = second
        .sample(
            deadline(Duration::from_secs(2))?,
            Arc::new(AtomicBool::new(false)),
        )
        .await;
    assert_eq!(
        exhausted.err().ok_or("sample identifier wrapped")?.kind(),
        ErrorKind::ResourceExhausted
    );
    Ok(())
}

#[cfg(test)]
#[tokio::test]
async fn closing_view_cancels_inflight_reachability_before_native_work_returns() -> TestResult {
    let (service, owner, _) = running().await?;
    let (entered, started) = tokio::sync::oneshot::channel();
    let entered = Mutex::new(Some(entered));
    let (release, released) = mpsc::channel();
    let released = Mutex::new(released);
    let sampler = Arc::new(WindowsSampler::with_provider(Arc::new(move |_, _| {
        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(reachability(NetworkStatus::Available))
    })));
    let pending = tokio::spawn(refresh_with_sampler(
        owner.clone(),
        owner.refresh_target()?,
        sampler,
        deadline(Duration::from_secs(30))?,
    ));
    started.await?;
    owner.request_close();
    let cancelled = tokio::time::timeout(Duration::from_secs(2), pending).await??;
    assert_eq!(
        cancelled.err().ok_or("closed view published")?.kind(),
        ErrorKind::Closed
    );
    release.send(())?;
    assert!(matches!(owner.snapshot()?.state, MonitorState::Closed));
    service.shutdown().await?;
    Ok(())
}