use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, Weak};
use std::time::Duration;
use crate::common::log::log_def::LogType;
use crate::common::CommonEngine;
use n0_watcher::Watcher as _;
use tokio::sync::{oneshot, watch};
use tokio::time::{self, MissedTickBehavior};
use super::monitor_runtime::{MonitorCompletion, MonitorInitialization, MonitorRuntime};
use super::monitor_state::MonitorState;
use super::network_status_snapshot::{
NetworkPublication, NetworkStatusPublisher, NetworkStatusSnapshot, NetworkStatusSource,
};
use super::platform::PlatformNetworkMonitor;
use super::refresh_trigger::{request_refresh_or_stop, RefreshWorkOutcome};
use crate::error::{NetError, NetworkMonitorDiagnostic, NetworkMonitorPhase};
use crate::module::net_status::logging::{Fault, FaultCycle};
use crate::module::net_status::IpStack;
#[cfg(any(not(target_os = "windows"), test))]
use crate::module::net_status::NetworkStatus;
use crate::net_status::{MonitorState as PublicMonitorState, NetworkSnapshot};
use crate::subscription::common_executor::CommonCallbackExecutor;
#[cfg(test)]
use crate::subscription::StateReceiver;
#[cfg(test)]
#[path = "network_observation_tests.rs"]
mod network_observation_tests;
#[cfg(test)]
#[path = "initialization_tests.rs"]
mod initialization_tests;
#[derive(Default)]
struct Lifecycle {
monitor: Option<MonitorRuntime>,
stopping: Vec<watch::Receiver<bool>>,
destroyed: bool,
}
struct MonitorTaskCompletion {
started_at: std::time::Instant,
lifecycle: Weak<Mutex<Lifecycle>>,
active: Arc<AtomicBool>,
state: Arc<Mutex<MonitorState>>,
initial_state: watch::Sender<MonitorInitialization>,
initialization_error: Option<NetError>,
observation: NetworkStatusPublisher,
completion: Option<MonitorCompletion>,
}
impl Drop for MonitorTaskCompletion {
fn drop(&mut self) {
let stopped = !self.active.swap(false, Ordering::AcqRel);
let retired = self.lifecycle.upgrade().and_then(|lifecycle| {
let mut lifecycle = match lifecycle.lock() {
Ok(lifecycle) => lifecycle,
Err(poisoned) => {
crate::log_e!(LogType::Engine; "network_status_monitor_exit", "error", "lifecycle_lock_poisoned_recovered");
poisoned.into_inner()
}
};
if lifecycle
.monitor
.as_ref()
.is_some_and(|monitor| Arc::ptr_eq(&monitor.active, &self.active))
{
let monitor = lifecycle.monitor.take();
if let Some(monitor) = &monitor {
lifecycle.stopping.push(monitor.finished.clone());
}
monitor
} else {
None
}
});
{
let _state = match self.state.lock() {
Ok(state) => state,
Err(poisoned) => {
crate::log_e!(LogType::Engine; "network_status_monitor_exit", "error", "state_lock_poisoned_recovered");
poisoned.into_inner()
}
};
}
let failure = self
.initialization_error
.clone()
.or_else(|| {
(!stopped).then(|| NetError::from(crate::error::ErrorKind::RuntimeUnavailable))
})
.map(|error| {
error.with_network_monitor_diagnostic(NetworkMonitorDiagnostic {
phase: NetworkMonitorPhase::MonitorTaskExit,
elapsed: Some(self.started_at.elapsed()),
timeout: None,
})
});
let terminal = failure
.clone()
.map_or(PublicMonitorState::Stopped, PublicMonitorState::Failed);
let publication = self.observation.prepare_finish(terminal);
drop(retired);
drop(self.completion.take());
self.initial_state.send_if_modified(|initial| {
if !matches!(initial, MonitorInitialization::Pending) {
return false;
}
*initial = match failure {
Some(error) => MonitorInitialization::Failed(error),
None if stopped => MonitorInitialization::Stopped,
None => MonitorInitialization::Failed(
NetError::from(crate::error::ErrorKind::RuntimeUnavailable)
.with_network_monitor_phase(NetworkMonitorPhase::MonitorTaskExit),
),
};
true
});
if let Err(error) = publication.and_then(NetworkPublication::dispatch) {
crate::log_e!(LogType::Engine; "net_status.drop", "event|kind|stage", "network_status_monitor_exit", format!("{:?}", error.kind()), format!("{:?}", error.context().stage));
}
}
}
fn take_monitor_completion(
handoff: &Mutex<Option<MonitorTaskCompletion>>,
) -> Option<MonitorTaskCompletion> {
match handoff.lock() {
Ok(mut slot) => slot.take(),
Err(poisoned) => poisoned.into_inner().take(),
}
}
pub(crate) struct InnerNetStatusClient {
engine: Arc<CommonEngine>,
lifecycle: Arc<Mutex<Lifecycle>>,
observations: NetworkStatusSource,
#[cfg(any(target_os = "windows", test))]
windows_reachability_sampler: Arc<super::refresh::WindowsSampler>,
#[cfg(test)]
monitor_factory: Mutex<Option<initialization_tests::MonitorFactory>>,
#[cfg(test)]
monitor_task: Mutex<Option<tokio::task::AbortHandle>>,
#[cfg(test)]
startup_faults: Mutex<startup_diagnostic_tests::StartupFaults>,
}
impl InnerNetStatusClient {
pub(crate) fn new(engine: Arc<CommonEngine>) -> Result<Self, NetError> {
let executor = Arc::new(CommonCallbackExecutor::new(&engine));
let observations =
NetworkStatusSource::new(executor, 1024)?.with_retirement(engine.retirement_work());
#[cfg(any(target_os = "windows", test))]
let windows_reachability_sampler =
super::refresh::WindowsSampler::new(engine.resource_threads());
Ok(Self {
engine,
lifecycle: Arc::new(Mutex::new(Lifecycle::default())),
observations,
#[cfg(any(target_os = "windows", test))]
windows_reachability_sampler,
#[cfg(test)]
monitor_factory: Mutex::new(None),
#[cfg(test)]
monitor_task: Mutex::new(None),
#[cfg(test)]
startup_faults: Mutex::new(startup_diagnostic_tests::StartupFaults::default()),
})
}
#[cfg_attr(not(any(feature = "ws-client", test)), allow(dead_code))]
pub(crate) fn subscribe(&self) -> watch::Receiver<NetworkStatusSnapshot> {
self.observations.subscribe()
}
pub(crate) fn subscribe_facts(&self) -> watch::Receiver<NetworkSnapshot> {
self.observations.subscribe_facts()
}
pub(super) fn observation_source(&self) -> NetworkStatusSource {
self.observations.clone()
}
#[cfg(any(target_os = "windows", test))]
pub(super) fn windows_reachability_sampler(&self) -> Arc<super::refresh::WindowsSampler> {
self.windows_reachability_sampler.clone()
}
pub(crate) fn subscribe_failure(&self) -> watch::Receiver<Option<NetError>> {
self.observations.subscribe_failure()
}
#[cfg(test)]
pub(crate) fn set_monitor_factory_for_test(
&self,
factory: initialization_tests::MonitorFactory,
) -> Result<(), NetError> {
*self.monitor_factory.lock().map_err(NetError::from_poison)? = Some(factory);
Ok(())
}
#[cfg(test)]
pub(crate) fn abort_monitor_task_for_test(&self) -> Result<(), NetError> {
let task = self.monitor_task.lock().map_err(NetError::from_poison)?;
match task.as_ref() {
Some(task) => {
task.abort();
Ok(())
}
None => Err(NetError::from(crate::error::ErrorKind::Internal)),
}
}
#[cfg(test)]
pub(crate) fn exhaust_source_revision_for_test(&self) -> Result<(), NetError> {
self.observations.exhaust_revision_for_test()
}
#[cfg(test)]
pub(crate) fn publish_observation_for_test(
&self,
status: NetworkStatus,
ip: IpStack,
_name: Option<String>,
) -> Result<(), NetError> {
let state = self
.current_state()?
.ok_or_else(|| NetError::from(crate::error::ErrorKind::Internal))?;
let publication = {
let state = state.lock().map_err(NetError::from_poison)?;
let publisher = state
.observation
.as_ref()
.ok_or_else(|| NetError::from(crate::error::ErrorKind::Internal))?;
publisher.prepare_observation(status, Some(ip))?
};
publication.dispatch()
}
pub(crate) async fn start(&self) -> Result<NetworkSnapshot, NetError> {
let (initial_state, task, publication) = loop {
let retiring = {
let mut lifecycle = self.lifecycle.lock().map_err(NetError::from_poison)?;
if lifecycle.destroyed {
return Err(NetError::from(crate::error::ErrorKind::Closed));
}
lifecycle
.stopping
.retain(|finished| !*::tokio::sync::watch::Receiver::borrow(finished));
if lifecycle.stopping.is_empty() {
let (task, publication) = if lifecycle.monitor.is_none() {
match self.prepare_monitor_task() {
Ok((monitor, task, publication)) => {
lifecycle.monitor = Some(monitor);
(Some(task), Some(publication))
}
Err(error) => {
drop(lifecycle);
match self.observations.fail(error.clone()) {
Ok(publication) => {
if let Err(dispatch_error) = publication.dispatch() {
crate::log_e!(LogType::Engine; "net_status.start", "event|kind|stage", "network_status_start_failure", format!("{:?}", dispatch_error.kind()), format!("{:?}", dispatch_error.context().stage));
}
}
Err(failure_error) => {
crate::log_e!(LogType::Engine; "net_status.start", "event|kind|stage", "network_status_start_failure", format!("{:?}", failure_error.kind()), format!("{:?}", failure_error.context().stage));
}
}
return Err(error);
}
}
} else {
(None, None)
};
let monitor = lifecycle
.monitor
.as_ref()
.ok_or(NetError::from(crate::error::ErrorKind::Internal))?;
break (monitor.initial_state.clone(), task, publication);
}
lifecycle.stopping.clone()
};
Self::wait_until_finished(retiring).await?;
};
if let Err(error) = publication
.as_ref()
.map(NetworkPublication::result)
.transpose()
{
drop(task);
if let Some(publication) = publication {
if let Err(dispatch_error) = publication.dispatch() {
crate::log_e!(LogType::Engine; "net_status.start", "event|kind|stage", "network_status_start", format!("{:?}", dispatch_error.kind()), format!("{:?}", dispatch_error.context().stage));
}
}
return Err(error.with_network_monitor_phase(NetworkMonitorPhase::ObservationCommit));
}
if let Some(task) = task {
let submitted = self.engine.runtime_handle().spawn(task);
#[cfg(test)]
{
*self.monitor_task.lock().map_err(NetError::from_poison)? =
Some(submitted.abort_handle());
}
#[cfg(not(test))]
drop(submitted);
}
if let Some(publication) = publication {
publication.dispatch().map_err(|error| {
error.with_network_monitor_phase(NetworkMonitorPhase::ObservationCommit)
})?;
}
let initialization = Self::wait_for_initialization(initial_state).await;
if self
.lifecycle
.lock()
.map_err(NetError::from_poison)?
.destroyed
{
return Err(NetError::from(crate::error::ErrorKind::Closed));
}
match initialization? {
MonitorInitialization::Ready | MonitorInitialization::Stopped => self.snapshot(),
MonitorInitialization::Failed(error) => Err(error),
MonitorInitialization::Pending => {
Err(NetError::from(crate::error::ErrorKind::RuntimeUnavailable)
.with_network_monitor_phase(NetworkMonitorPhase::InitialResultReceive))
}
}
}
async fn wait_for_initialization(
mut initial_state: watch::Receiver<MonitorInitialization>,
) -> Result<MonitorInitialization, NetError> {
loop {
let current = initial_state.borrow_and_update().clone();
if !matches!(current, MonitorInitialization::Pending) {
return Ok(current);
}
initial_state.changed().await.map_err(|source| {
NetError::with_source(crate::error::ErrorKind::RuntimeUnavailable, source)
.with_network_monitor_phase(NetworkMonitorPhase::InitialResultReceive)
})?;
}
}
fn prepare_monitor_task(
&self,
) -> Result<
(
MonitorRuntime,
impl std::future::Future<Output = ()> + Send + 'static,
NetworkPublication,
),
NetError,
> {
#[cfg(test)]
let factory = self
.monitor_factory
.lock()
.map_err(NetError::from_poison)?
.clone();
#[cfg(test)]
let startup_faults = *self.startup_faults.lock().map_err(NetError::from_poison)?;
let (stop_sender, stop_receiver) = oneshot::channel();
let (initial_sender, initial_state) = watch::channel(MonitorInitialization::Pending);
let (finished_sender, finished) = watch::channel(false);
let (publisher, publication) = self.observations.begin_generation().map_err(|error| {
error.with_network_monitor_phase(NetworkMonitorPhase::ObservationCommit)
})?;
let state = MonitorState {
observation: Some(publisher.clone()),
..MonitorState::default()
};
let active = Arc::clone(&state.active);
let state = Arc::new(Mutex::new(state));
let shared_state = Arc::clone(&state);
let completion = MonitorTaskCompletion {
started_at: std::time::Instant::now(),
lifecycle: Arc::downgrade(&self.lifecycle),
active: Arc::clone(&active),
state: Arc::clone(&state),
initial_state: initial_sender.clone(),
initialization_error: publication.result().err().map(|error| {
error.with_network_monitor_phase(NetworkMonitorPhase::ObservationCommit)
}),
observation: publisher,
completion: Some(MonitorCompletion(finished_sender)),
};
#[cfg(target_os = "windows")]
let windows_reachability_sampler = self.windows_reachability_sampler.clone();
let threads = self.engine.resource_threads();
let task = async move {
let (submission_alive, submission_cancelled) = oneshot::channel::<()>();
let (thread_finished, thread_wait) = oneshot::channel();
let handoff = Arc::new(Mutex::new(Some(completion)));
let worker_handoff = handoff.clone();
let spawned = Self::spawn_monitor_thread(
&threads,
move || {
let Some(mut completion) = take_monitor_completion(&worker_handoff) else {
return;
};
let runtime = match Self::build_monitor_runtime(
#[cfg(test)]
startup_faults.runtime_build_os_error,
) {
Ok(runtime) => runtime,
Err(error) => {
completion.initialization_error = Some(
NetError::with_source(
crate::error::ErrorKind::RuntimeUnavailable,
error,
)
.with_network_monitor_phase(NetworkMonitorPhase::RuntimeBuild),
);
return;
}
};
let outcome = runtime.block_on(async move {
tokio::select! {
biased;
_ = submission_cancelled => Err(
NetError::from(crate::error::ErrorKind::RuntimeUnavailable)
.with_network_monitor_phase(NetworkMonitorPhase::MonitorTaskSubmit)
),
result = Self::monitor_until_stopped(
shared_state,
stop_receiver,
initial_sender,
#[cfg(target_os = "windows")]
windows_reachability_sampler,
#[cfg(test)]
factory,
) => result,
}
});
drop(runtime);
if let Err(error) = outcome {
completion.initialization_error = Some(error);
}
drop(completion);
let _ = thread_finished.send(());
},
#[cfg(test)]
startup_faults.thread_spawn_os_error,
);
if let Err(error) = spawned {
if let Some(mut completion) = take_monitor_completion(&handoff) {
completion.initialization_error = Some(
NetError::with_source(crate::error::ErrorKind::RuntimeUnavailable, error)
.with_network_monitor_phase(NetworkMonitorPhase::MonitorThreadSpawn),
);
drop(completion);
}
}
drop(handoff);
let _ = thread_wait.await;
drop(submission_alive);
};
let monitor = MonitorRuntime {
stop_sender: Some(stop_sender),
initial_state,
finished,
state,
active,
};
Ok((monitor, task, publication))
}
fn spawn_monitor_thread(
threads: &Arc<crate::common::retirement::ThreadRegistry>,
run: impl FnOnce() + Send + 'static,
#[cfg(test)] injected_os_error: Option<i32>,
) -> std::io::Result<()> {
#[cfg(test)]
if let Some(code) = injected_os_error {
drop(run);
return Err(std::io::Error::from_raw_os_error(code));
}
threads.spawn("open-net-network-monitor", run)
}
fn build_monitor_runtime(
#[cfg(test)] injected_os_error: Option<i32>,
) -> std::io::Result<tokio::runtime::Runtime> {
#[cfg(test)]
if let Some(code) = injected_os_error {
return Err(std::io::Error::from_raw_os_error(code));
}
tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
}
pub(crate) fn request_stop(
&self,
permanent: bool,
) -> (Vec<watch::Receiver<bool>>, Option<NetError>) {
#[cfg(any(target_os = "windows", test))]
if permanent {
self.windows_reachability_sampler.close();
}
let mut error = None;
let (finished, retired, publication) = {
let mut lifecycle = match self.lifecycle.lock() {
Ok(lifecycle) => lifecycle,
Err(poisoned) => {
error = Some(NetError::from(crate::error::ErrorKind::Internal));
poisoned.into_inner()
}
};
lifecycle.destroyed |= permanent;
let mut retired = lifecycle.monitor.take();
if let Some(monitor) = &mut retired {
monitor.active.store(false, Ordering::Release);
if let Some(stop) = monitor.stop_sender.take() {
let _ = stop.send(());
}
lifecycle.stopping.push(monitor.finished.clone());
}
let publication = if permanent {
self.observations.prepare_closed()
} else {
self.observations.prepare_stopped()
};
lifecycle
.stopping
.retain(|finished| !*::tokio::sync::watch::Receiver::borrow(finished));
(lifecycle.stopping.clone(), retired, publication)
};
drop(retired);
if let Err(publication_error) = publication.and_then(NetworkPublication::dispatch) {
crate::log_e!(LogType::Engine; "net_status.request_stop", "permanent|kind|stage", permanent, format!("{:?}", publication_error.kind()), format!("{:?}", publication_error.context().stage));
error = Some(publication_error);
}
(finished, error)
}
pub(crate) async fn wait_until_finished(
finished: Vec<watch::Receiver<bool>>,
) -> Result<(), NetError> {
for mut receiver in finished {
while !*receiver.borrow_and_update() {
if receiver.changed().await.is_err() {
return Err(NetError::from(crate::error::ErrorKind::RuntimeUnavailable));
}
}
}
Ok(())
}
#[cfg(test)]
pub(crate) async fn stop(&self) -> Result<(), NetError> {
let (finished, error) = self.request_stop(false);
Self::wait_until_finished(finished).await?;
error.map_or(Ok(()), Err)
}
pub(crate) fn request_destroy(&self) {
self.request_stop(true);
}
#[cfg(test)]
pub(crate) async fn destroy(&self) -> Result<(), NetError> {
let (finished, error) = self.request_stop(true);
Self::wait_until_finished(finished).await?;
error.map_or(Ok(()), Err)
}
#[cfg(test)]
pub(crate) async fn shutdown(&self) -> Result<(), NetError> {
self.destroy().await
}
pub(crate) fn snapshot(&self) -> Result<NetworkSnapshot, NetError> {
self.observations.snapshot()
}
#[cfg(test)]
pub(crate) fn subscribe_state(&self) -> Result<StateReceiver<NetworkSnapshot>, NetError> {
self.observations.observe()
}
#[cfg(test)]
fn current_state(&self) -> Result<Option<Arc<Mutex<MonitorState>>>, NetError> {
Ok(self
.lifecycle
.lock()
.map_err(NetError::from_poison)?
.monitor
.as_ref()
.map(|monitor| Arc::clone(&monitor.state)))
}
#[cfg(test)]
fn is_started(&self) -> bool {
matches!(self.snapshot(), Ok(snapshot) if matches!(snapshot.state, PublicMonitorState::Running))
}
#[cfg(any(not(any(target_os = "linux", target_os = "windows")), test))]
fn reachability_from_flags(
has_default_route: bool,
have_v4: bool,
have_v6: bool,
) -> NetworkStatus {
if has_default_route && (have_v4 || have_v6) {
NetworkStatus::Available
} else {
NetworkStatus::Unavailable
}
}
#[cfg(not(any(target_os = "linux", target_os = "windows")))]
fn reachability_from_state(state: &netwatch::netmon::State) -> NetworkStatus {
Self::reachability_from_flags(
state.default_route_interface.is_some(),
state.have_v4,
state.have_v6,
)
}
fn ip_stack_from_state(state: &netwatch::netmon::State) -> IpStack {
IpStack::from_flags(state.have_v4, state.have_v6)
}
#[cfg(not(target_os = "windows"))]
async fn reachability_or_stop(
snapshot: &netwatch::netmon::State,
_stop_receiver: &mut oneshot::Receiver<()>,
) -> Result<Option<NetworkStatus>, NetError> {
#[cfg(target_os = "linux")]
{
tokio::select! {
biased;
_ = &mut *_stop_receiver => Ok(None),
result = super::platform::linux::current_reachability(snapshot) => result.map(Some),
}
}
#[cfg(not(target_os = "linux"))]
{
Ok(Some(Self::reachability_from_state(snapshot)))
}
}
#[cfg(any(not(target_os = "windows"), test))]
fn update_state_inner(
state: &Arc<Mutex<MonitorState>>,
reachability: NetworkStatus,
ip_stack: IpStack,
) -> Result<(), NetError> {
let publication = {
let guard = state.lock().map_err(NetError::from_poison)?;
if !guard.active.load(Ordering::Acquire) {
return Ok(());
}
match &guard.observation {
Some(observation) => {
Some(observation.prepare_observation(reachability, Some(ip_stack))?)
}
None => None,
}
};
if let Some(publication) = publication {
publication.dispatch()?;
}
Ok(())
}
async fn monitor_until_stopped(
state: Arc<Mutex<MonitorState>>,
mut stop_receiver: oneshot::Receiver<()>,
initial_state: watch::Sender<MonitorInitialization>,
#[cfg(target_os = "windows")] windows_reachability_sampler: Arc<
super::refresh::WindowsSampler,
>,
#[cfg(test)] factory: Option<initialization_tests::MonitorFactory>,
) -> Result<(), NetError> {
let monitor = tokio::select! {
biased;
_ = &mut stop_receiver => return Ok(()),
result = Self::create_monitor(
#[cfg(test)]
factory,
) => result,
};
let monitor = match monitor {
Ok(monitor) => monitor,
Err(error) => {
return Err(error);
}
};
let mut interface_state = monitor.interface_state();
let mut refresh_faults = FaultCycle::default();
#[cfg(target_os = "windows")]
let mut reachability_faults = FaultCycle::default();
let initial = interface_state.get();
if !Self::observe_or_stop(
&state,
&initial,
&mut stop_receiver,
#[cfg(target_os = "windows")]
&windows_reachability_sampler,
#[cfg(target_os = "windows")]
&mut reachability_faults,
)
.await?
{
return Ok(());
}
initial_state.send_replace(MonitorInitialization::Ready);
#[cfg(target_os = "macos")]
tokio::task::yield_now().await;
let mut platform_monitor = PlatformNetworkMonitor::start();
let mut refresh_interval = time::interval(Duration::from_secs(2));
refresh_interval.set_missed_tick_behavior(MissedTickBehavior::Skip);
let observations = async {
loop {
tokio::select! {
biased;
_ = &mut stop_receiver => break,
update = interface_state.updated() => {
match update {
Ok(new_state) => {
if !Self::resample_or_stop(&state, &new_state, &mut stop_receiver,
#[cfg(target_os = "windows")] &windows_reachability_sampler,
#[cfg(target_os = "windows")] &mut reachability_faults,
).await? {
break;
}
}
Err(_) => break,
}
}
native_changed = platform_monitor.changed() => {
if native_changed {
match request_refresh_or_stop(
&mut stop_receiver,
|| monitor.network_change(),
).await {
RefreshWorkOutcome::Stopped => break,
RefreshWorkOutcome::Requested => refresh_faults.recovered("refresh_request"),
RefreshWorkOutcome::RequestFailed => refresh_faults.failure("refresh_request", Fault::RefreshRequest),
}
}
}
_ = refresh_interval.tick() => {
#[cfg(target_os = "linux")]
match request_refresh_or_stop(
&mut stop_receiver,
|| monitor.network_change(),
).await {
RefreshWorkOutcome::Stopped => break,
RefreshWorkOutcome::Requested => refresh_faults.recovered("refresh_request"),
RefreshWorkOutcome::RequestFailed => refresh_faults.failure("refresh_request", Fault::RefreshRequest),
}
let snapshot = interface_state.get();
if !Self::resample_or_stop(&state, &snapshot, &mut stop_receiver,
#[cfg(target_os = "windows")] &windows_reachability_sampler,
#[cfg(target_os = "windows")] &mut reachability_faults,
).await? {
break;
}
}
}
}
Ok::<(), NetError>(())
};
observations.await?;
#[cfg(target_os = "macos")]
drop(platform_monitor);
Ok(())
}
async fn create_monitor(
#[cfg(test)] factory: Option<initialization_tests::MonitorFactory>,
) -> Result<netwatch::netmon::Monitor, NetError> {
#[cfg(test)]
if let Some(factory) = factory {
return factory().await.map_err(|error| {
error.with_network_monitor_phase(NetworkMonitorPhase::NetwatchCreate)
});
}
netwatch::netmon::Monitor::new().await.map_err(|error| {
crate::log_e!(LogType::Engine; "net_status.create_monitor", "reason", "monitor_creation_failed");
NetError::with_source(crate::error::ErrorKind::RuntimeUnavailable, error)
.with_stage(crate::error::ErrorStage::NetworkMonitor)
.with_network_monitor_phase(NetworkMonitorPhase::NetwatchCreate)
})
}
async fn observe_or_stop(
state: &Arc<Mutex<MonitorState>>,
snapshot: &netwatch::netmon::State,
stop: &mut oneshot::Receiver<()>,
#[cfg(target_os = "windows")] sampler: &super::refresh::WindowsSampler,
#[cfg(target_os = "windows")] faults: &mut FaultCycle,
) -> Result<bool, NetError> {
Self::observe_with_policy(
state,
snapshot,
stop,
false,
#[cfg(target_os = "windows")]
sampler,
#[cfg(target_os = "windows")]
faults,
)
.await
}
async fn resample_or_stop(
state: &Arc<Mutex<MonitorState>>,
snapshot: &netwatch::netmon::State,
stop: &mut oneshot::Receiver<()>,
#[cfg(target_os = "windows")] sampler: &super::refresh::WindowsSampler,
#[cfg(target_os = "windows")] faults: &mut FaultCycle,
) -> Result<bool, NetError> {
Self::observe_with_policy(
state,
snapshot,
stop,
true,
#[cfg(target_os = "windows")]
sampler,
#[cfg(target_os = "windows")]
faults,
)
.await
}
async fn observe_with_policy(
state: &Arc<Mutex<MonitorState>>,
snapshot: &netwatch::netmon::State,
stop: &mut oneshot::Receiver<()>,
_retry_transient: bool,
#[cfg(target_os = "windows")] sampler: &super::refresh::WindowsSampler,
#[cfg(target_os = "windows")] faults: &mut FaultCycle,
) -> Result<bool, NetError> {
#[cfg(not(target_os = "windows"))]
{
let Some(reachability) = Self::reachability_or_stop(snapshot, stop).await? else {
return Ok(false);
};
Self::update_state_inner(state, reachability, Self::ip_stack_from_state(snapshot))?;
}
#[cfg(target_os = "windows")]
{
let cancel = super::refresh::Cancellation::new();
let deadline = std::time::Instant::now() + Duration::from_secs(10);
let progress = Arc::new(super::sample_diagnostics::SampleProgress::new(deadline));
let sampled = tokio::select! {
biased;
_ = &mut *stop => return Ok(false),
result = async {
tokio::time::timeout_at(
tokio::time::Instant::from_std(deadline),
sampler.sample_background_tracked(deadline, cancel.flag.clone(), progress.clone()),
).await.map_err(|_| progress.annotate(NetError::from(crate::error::ErrorKind::TimedOut)))?
} => result,
};
let failure = sampled.as_ref().err().map(Fault::from_error);
let sampled = Self::classify_windows_sample(sampled, _retry_transient)?;
let Some(sampled) = sampled else {
if let Some(failure) = failure {
faults.failure("reachability_sample", failure);
}
return Ok(true);
};
let mut commit_fault = None;
let (keep_running, publication) = Self::prepare_windows_sample(
state,
&cancel,
deadline,
_retry_transient,
sampled,
Self::ip_stack_from_state(snapshot),
&mut commit_fault,
)
.map_err(|error| {
progress.annotate(error.with_network_monitor_phase(
crate::error::NetworkMonitorPhase::ObservationCommit,
))
})?;
if !keep_running {
return Ok(false);
}
if let Some(failure) = commit_fault {
faults.failure("reachability_sample", failure);
}
if let Some(publication) = publication {
publication.dispatch().map_err(|error| {
progress.annotate(
error.with_network_monitor_phase(NetworkMonitorPhase::ObservationCommit),
)
})?;
if commit_fault.is_none() {
faults.recovered("reachability_sample");
}
}
}
Ok(true)
}
#[cfg(test)]
async fn complete_windows_sample<T>(
sample: impl std::future::Future<Output = Result<T, NetError>>,
retry_transient: bool,
) -> Result<Option<T>, NetError> {
Self::classify_windows_sample(sample.await, retry_transient)
}
#[cfg(any(target_os = "windows", test))]
fn prepare_windows_sample(
state: &Arc<Mutex<MonitorState>>,
cancel: &super::refresh::Cancellation,
deadline: std::time::Instant,
retry_transient: bool,
sampled: super::refresh::CompletedSample,
ip_stack: IpStack,
fault: &mut Option<Fault>,
) -> Result<(bool, Option<NetworkPublication>), NetError> {
let monitor = state.lock().map_err(NetError::from_poison)?;
if !monitor.active.load(Ordering::Acquire) {
return Ok((false, None));
}
let validity = cancel.check(deadline);
let failure = validity.as_ref().err().map(Fault::from_error);
if Self::classify_windows_sample(validity, retry_transient)?.is_none() {
*fault = failure;
return Ok((true, None));
}
let publication = match &monitor.observation {
Some(publisher) => publisher.prepare_sampled_observation(
sampled.id,
sampled.observation.reachability,
Some(ip_stack),
sampled.sampled_at,
|| {
let validity = cancel.check(deadline);
let failure = validity.as_ref().err().map(Fault::from_error);
let valid = Self::classify_windows_sample(validity, retry_transient)?.is_some();
if !valid {
*fault = failure;
}
Ok(valid)
},
)?,
None => None,
};
Ok((true, publication))
}
#[cfg(any(target_os = "windows", test))]
fn classify_windows_sample<T>(
sample: Result<T, NetError>,
retry_transient: bool,
) -> Result<Option<T>, NetError> {
match sample {
Err(error)
if retry_transient
&& matches!(
error.kind(),
crate::error::ErrorKind::QueueFull
| crate::error::ErrorKind::TimedOut
| crate::error::ErrorKind::ResourceExhausted
) =>
{
Ok(None)
}
result => result.map(Some),
}
}
}
impl Drop for InnerNetStatusClient {
fn drop(&mut self) {
self.request_destroy();
}
}
#[cfg(test)]
#[path = "lifecycle_tests.rs"]
mod tests;
#[cfg(test)]
#[path = "startup_diagnostic_tests.rs"]
mod startup_diagnostic_tests;
#[cfg(test)]
#[path = "resample_tests.rs"]
mod resample_tests;
#[cfg(test)]
#[path = "background_name_tests.rs"]
mod connectivity_minimization_tests;
#[cfg(all(test, target_os = "windows"))]
#[path = "windows_startup_diagnostics_tests.rs"]
mod windows_startup_diagnostics_tests;