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::*;
use futures::{executor::block_on, task::noop_waker_ref};
use std::future::Future;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::time::Duration;

type TestResult<T = ()> = std::result::Result<T, crate::BoxError>;
fn check(value: bool, message: &str) -> TestResult {
    if value {
        Ok(())
    } else {
        Err(std::io::Error::other(message).into())
    }
}
#[derive(Default)]
struct ManualExecutor {
    jobs: Mutex<VecDeque<Box<dyn FnOnce() + Send>>>,
}
impl CallbackExecutor for ManualExecutor {
    fn ensure_ready(&self) -> Result<()> {
        Ok(())
    }
    fn submit(&self, job: Box<dyn FnOnce() + Send>) -> Result<()> {
        self.jobs
            .lock()
            .map_err(NetError::from_poison)?
            .push_back(job);
        Ok(())
    }
}
impl ManualExecutor {
    fn next(&self) -> TestResult<Option<Box<dyn FnOnce() + Send>>> {
        Ok(self
            .jobs
            .lock()
            .map_err(|_| std::io::Error::other("jobs lock"))?
            .pop_front())
    }
}
fn channel<T>(
    executor: Arc<ManualExecutor>,
) -> TestResult<(
    super::super::EventPublisher<T>,
    super::super::EventReceiver<T>,
)> {
    Ok(super::super::event_channel(
        EventQueueLimit {
            max_items: 1,
            max_bytes: 8,
        },
        EventOverflow::DropOldest,
        executor,
        None,
    )?)
}

#[test]
fn event_runner_fault_retires_running_state_and_close_reports_it() -> TestResult {
    let executor = Arc::new(ManualExecutor::default());
    let (publisher, receiver) = channel(executor.clone())?;
    publisher.try_publish(7, 1)?;
    let registration = receiver.registration.clone();
    let subscription = receiver.into_callback(|_, _| {})?;
    lock(&registration.state).running = true;
    {
        let _completion = RunnerCompletion {
            registration: &registration,
            armed: true,
        };
        registration.complete_runner(Err(Box::new("caught runner fault")));
    }
    check(
        !subscription.is_active(),
        "runner fault kept callback active",
    )?;
    let error = block_on(subscription.close())
        .err()
        .ok_or("runner fault was not returned from close")?;
    check(
        error.kind() == ErrorKind::CallbackPanicked,
        "runner fault kind changed",
    )?;
    if let Some(job) = executor.next()? {
        job();
    }
    Ok(())
}

struct Release(Option<std::sync::mpsc::Sender<()>>);
impl Drop for Release {
    fn drop(&mut self) {
        if let Some(sender) = self.0.take() {
            let _ = sender.send(());
        }
    }
}

#[test]
fn one_event_callback_runs_while_close_discards_the_queued_successor_and_waits() -> TestResult {
    let executor = Arc::new(ManualExecutor::default());
    let (publisher, receiver) = channel(executor.clone())?;
    publisher.try_publish(1, 1)?;
    let concurrent = Arc::new(AtomicUsize::new(0));
    let failure = Arc::new(AtomicBool::new(false));
    let observed = Arc::new(Mutex::new(Vec::new()));
    let running = concurrent.clone();
    let failed = failure.clone();
    let values = observed.clone();
    let (entered, received) = std::sync::mpsc::channel();
    let (release, released) = std::sync::mpsc::channel();
    let released = Mutex::new(released);
    let release = Release(Some(release));
    let subscription = receiver.into_callback(move |_, value| {
        if running.fetch_add(1, Ordering::SeqCst) != 0 {
            failed.store(true, Ordering::SeqCst);
        }
        if let Ok(mut values) = values.lock() {
            values.push(value.ok());
        } else {
            failed.store(true, Ordering::SeqCst);
        }
        if entered.send(()).is_err() {
            failed.store(true, Ordering::SeqCst);
        }
        let released = released
            .lock()
            .ok()
            .and_then(|receiver| receiver.recv_timeout(Duration::from_secs(5)).ok());
        if released.is_none() {
            failed.store(true, Ordering::SeqCst);
        }
        running.fetch_sub(1, Ordering::SeqCst);
    })?;
    let job = executor
        .next()?
        .ok_or("initial callback was not scheduled")?;
    let worker = std::thread::Builder::new().spawn(job)?;
    received.recv_timeout(Duration::from_secs(5))?;
    publisher.try_publish(2, 1)?;
    check(
        executor.next()?.is_none(),
        "one subscription scheduled another concurrent job",
    )?;
    let mut close = Box::pin(subscription.close());
    let mut cx = Context::from_waker(noop_waker_ref());
    check(
        close.as_mut().poll(&mut cx).is_pending(),
        "close did not await acquired callback",
    )?;
    drop(release);
    worker
        .join()
        .map_err(|_| std::io::Error::other("callback job failed"))?;
    check(
        matches!(close.as_mut().poll(&mut cx), Poll::Ready(Ok(()))),
        "finished callback did not release close",
    )?;
    check(
        !failure.load(Ordering::SeqCst) && concurrent.load(Ordering::SeqCst) == 0,
        "callback overlapped or probe failed",
    )?;
    let only_first = observed
        .lock()
        .map_err(|_| std::io::Error::other("values lock"))?
        .as_slice()
        == [Some(1)];
    check(only_first, "unsubscribe delivered queued successor")
}

#[test]
fn lag_counter_exhaustion_rejects_publish_without_saturating_or_evicting() -> TestResult {
    let (publisher, mut receiver) = channel(Arc::new(ManualExecutor::default()))?;
    publisher.try_publish(1, 1)?;
    lock(&receiver.registration.state).lagged = u64::MAX;
    let error = publisher
        .try_publish(2, 1)
        .err()
        .ok_or("lag counter overflow was accepted")?;
    check(
        error.kind() == ErrorKind::ResourceExhausted,
        "wrong lag counter error",
    )?;
    check(
        matches!(
            receiver.try_recv(),
            Err(TryReceiveError::Lagged { skipped: u64::MAX })
        ),
        "lag count wrapped or saturated",
    )?;
    check(
        receiver.try_recv()? == 1,
        "rejected counter overflow evicted the existing item",
    )
}

#[test]
fn retirement_allocation_failure_does_not_change_queue_or_lag() -> TestResult {
    let (publisher, mut receiver) = channel(Arc::new(ManualExecutor::default()))?;
    publisher.try_publish(1, 1)?;
    lock(&receiver.registration.state).fail_retirement_reserve = true;
    let error = publisher
        .try_publish(2, 1)
        .err()
        .ok_or("retirement allocation failure was ignored")?;
    check(
        error.kind() == ErrorKind::ResourceExhausted,
        "wrong retirement error",
    )?;
    check(
        receiver.try_recv()? == 1,
        "failed retirement changed existing queue",
    )?;
    check(
        matches!(receiver.try_recv(), Err(TryReceiveError::Empty)),
        "failed retirement created a gap",
    )?;
    publisher.try_publish(3, 1)?;
    check(
        receiver.try_recv()? == 3,
        "retirement failure poisoned later publication",
    )
}

#[test]
fn event_limit_validation_and_subscription_ids_are_shared_with_state() -> TestResult {
    let executor = Arc::new(ManualExecutor::default());
    for limit in [
        EventQueueLimit {
            max_items: 0,
            max_bytes: 1,
        },
        EventQueueLimit {
            max_items: 1,
            max_bytes: 0,
        },
        EventQueueLimit {
            max_items: usize::MAX,
            max_bytes: 1,
        },
        EventQueueLimit {
            max_items: 1,
            max_bytes: usize::MAX,
        },
    ] {
        let error =
            super::super::event_channel::<()>(limit, EventOverflow::Wait, executor.clone(), None)
                .err()
                .ok_or("invalid event capacity accepted")?;
        check(
            error.kind() == ErrorKind::InvalidConfig,
            "capacity error category changed",
        )?;
    }
    let (_publisher, source) = super::super::StateSource::new(1, executor.clone(), 1)?;
    let state = source.subscribe()?;
    let (_publisher, event) = channel::<()>(executor)?;
    check(
        event.id().as_u64() > state.id().as_u64(),
        "event IDs do not share state subscription allocator",
    )
}