use crate::app_events::{self, AppEvent, Subscription};
use crate::runtime::current_runtime;
use crate::task::WorkerTask;
use crate::{Error, Operation, Result};
use parking_lot::RwLock;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use std::time::{Duration, Instant};
use url::Url;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum NetworkState {
Offline,
LocalOnly,
Online,
Unknown,
}
impl NetworkState {
const fn name(self) -> &'static str {
match self {
Self::Offline => "offline",
Self::LocalOnly => "local-only",
Self::Online => "online",
Self::Unknown => "unknown",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum NetworkTransport {
Wifi,
Cellular,
Ethernet,
Vpn,
Other,
Unknown,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NetworkStatus {
pub state: NetworkState,
pub transport: NetworkTransport,
pub expensive: Option<bool>,
pub constrained: Option<bool>,
}
impl NetworkStatus {
pub const fn offline() -> Self {
Self {
state: NetworkState::Offline,
transport: NetworkTransport::Unknown,
expensive: None,
constrained: None,
}
}
pub const fn online(transport: NetworkTransport) -> Self {
Self {
state: NetworkState::Online,
transport,
expensive: None,
constrained: None,
}
}
pub const fn is_online(&self) -> bool {
matches!(self.state, NetworkState::Online)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProbeResult {
pub url: Url,
pub reachable: bool,
pub status_code: Option<u16>,
pub latency: Duration,
}
#[derive(Debug)]
pub struct NetworkMonitor {
status: Arc<RwLock<NetworkStatus>>,
_subscription: Subscription,
}
impl NetworkMonitor {
pub fn current(&self) -> NetworkStatus {
self.status.read().clone()
}
}
pub fn is_supported() -> bool {
current_runtime().supports(Operation::NetworkStatus)
}
pub fn current() -> Result<NetworkStatus> {
let runtime = current_runtime();
runtime.ensure_supported(Operation::NetworkStatus)?;
runtime.backend().network_current()
}
pub fn subscribe(callback: impl Fn(NetworkStatus) + Send + Sync + 'static) -> Subscription {
app_events::subscribe(move |event| {
if let AppEvent::NetworkChanged(status) = event {
callback(status);
}
})
}
pub fn use_network_status() -> Result<NetworkMonitor> {
let initial = current()?;
let status = Arc::new(RwLock::new(initial));
let observed = Arc::clone(&status);
let subscription = subscribe(move |latest| {
*observed.write() = latest;
});
Ok(NetworkMonitor {
status,
_subscription: subscription,
})
}
pub fn is_online() -> Result<bool> {
current().map(|status| status.is_online())
}
pub fn require_online() -> Result<()> {
let status = current()?;
if status.is_online() {
Ok(())
} else {
Err(Error::Offline {
state: status.state.name(),
})
}
}
pub fn wait_until_online(timeout: Duration) -> Result<NetworkStatus> {
let runtime = current_runtime();
runtime.ensure_supported(Operation::NetworkStatus)?;
let events = app_events::stream();
let status = runtime.backend().network_current()?;
if status.is_online() {
return Ok(status);
}
let deadline = Instant::now()
.checked_add(timeout)
.ok_or_else(|| Error::invalid("network wait timeout", "duration is too large"))?;
loop {
let remaining = deadline.saturating_duration_since(Instant::now());
if remaining.is_zero() {
return Err(Error::Timeout {
operation: "wait until online",
timeout,
});
}
match events.recv_timeout(remaining) {
Ok(AppEvent::NetworkChanged(status)) if status.is_online() => return Ok(status),
Ok(_) => {}
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
return Err(Error::Timeout {
operation: "wait until online",
timeout,
});
}
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
return Err(Error::backend(
Operation::NetworkStatus,
"application event stream disconnected",
));
}
}
}
}
pub async fn probe(url: impl AsRef<str>, timeout: Duration) -> Result<ProbeResult> {
let url =
Url::parse(url.as_ref()).map_err(|error| Error::invalid("probe URL", error.to_string()))?;
if !matches!(url.scheme(), "http" | "https") {
return Err(Error::invalid(
"probe URL",
"only http and https URLs are allowed",
));
}
if timeout.is_zero() {
return Err(Error::invalid("probe timeout", "must be greater than zero"));
}
let runtime = current_runtime();
runtime.ensure_supported(Operation::NetworkProbe)?;
let backend = runtime.backend_arc();
WorkerTask::spawn(move || {
let (sender, receiver) = std::sync::mpsc::sync_channel(1);
std::thread::spawn(move || {
let result = backend.network_probe(&url, timeout);
let _ = sender.send(result);
});
match receiver.recv_timeout(timeout) {
Ok(result) => result,
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => Err(Error::Timeout {
operation: "network probe",
timeout,
}),
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => Err(Error::backend(
Operation::NetworkProbe,
"network probe worker disconnected",
)),
}
})
.await
.map_err(|_| Error::backend(Operation::NetworkProbe, "network probe worker panicked"))?
}
#[cfg(test)]
mod tests {
use super::*;
use crate::task::block_on;
use crate::testing::TestRuntime;
#[test]
fn status_does_not_imply_probe_result() {
let runtime = TestRuntime::new();
let _guard = runtime.enter();
runtime.set_network_status(NetworkStatus::online(NetworkTransport::Wifi));
runtime.set_probe_result(false, Some(503), Duration::from_millis(12));
assert!(is_online().unwrap());
let result =
block_on(probe("https://example.test/health", Duration::from_secs(1))).unwrap();
assert!(!result.reachable);
assert_eq!(result.status_code, Some(503));
}
#[test]
fn invalid_probe_scheme_never_reaches_backend() {
let runtime = TestRuntime::new();
let _guard = runtime.enter();
let error = block_on(probe("file:///private/data", Duration::from_secs(1))).unwrap_err();
assert!(matches!(error, Error::InvalidInput { .. }));
assert!(runtime.probe_requests().is_empty());
}
#[test]
fn live_monitor_updates_without_polling() {
let runtime = TestRuntime::new();
let _guard = runtime.enter();
let monitor = use_network_status().unwrap();
assert_eq!(monitor.current().state, NetworkState::Offline);
runtime.set_network_status(NetworkStatus::online(NetworkTransport::Ethernet));
assert_eq!(monitor.current().state, NetworkState::Online);
}
#[test]
fn wait_observes_injected_online_event() {
let runtime = TestRuntime::new();
let _guard = runtime.enter();
let updater = runtime.clone();
let thread = std::thread::spawn(move || {
updater.set_network_status(NetworkStatus::online(NetworkTransport::Wifi));
});
let status = wait_until_online(Duration::from_secs(1)).unwrap();
thread.join().unwrap();
assert!(status.is_online());
}
}