Skip to main content

open_net/module/net_status/inner/
shared.rs

1//! Engine-scoped network observation ownership. Consumers only retain weak
2//! service contexts and explicit, idempotently releasable demand leases.
3use std::collections::HashSet;
4use std::future::Future;
5use std::pin::Pin;
6use std::sync::{Arc, Mutex, Weak};
7
8use tokio::sync::{mpsc, oneshot, watch};
9
10use super::inner_net_status_client::InnerNetStatusClient;
11use super::network_status_snapshot::NetworkStatusSnapshot;
12use crate::common::CommonEngine;
13use crate::error::{ErrorKind, NetError};
14use crate::net_status::{MonitorState, NetworkSnapshot};
15
16/// A read-only handle to the network facts owned by one `OpenNet` engine.
17/// Cloning or reading it never starts monitoring or extends the engine lifetime.
18/// A context remains tied to its original engine after that engine is dropped.
19#[derive(Clone)]
20pub struct NetworkStatusContext {
21    service: Weak<SharedNetworkService>,
22    facts: watch::Receiver<NetworkSnapshot>,
23    failure: watch::Receiver<Option<NetError>>,
24    gate: watch::Receiver<NetworkStatusSnapshot>,
25}
26impl std::fmt::Debug for NetworkStatusContext {
27    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
28        f.debug_struct("NetworkStatusContext")
29            .finish_non_exhaustive()
30    }
31}
32impl NetworkStatusContext {
33    pub(super) fn observation_source(
34        &self,
35    ) -> Result<super::network_status_snapshot::NetworkStatusSource, NetError> {
36        self.service
37            .upgrade()
38            .map(|service| service.inner.observation_source())
39            .ok_or_else(|| NetError::from(ErrorKind::Closed))
40    }
41    #[cfg(any(windows, test))]
42    pub(super) fn windows_sampler(&self) -> Result<Arc<super::refresh::WindowsSampler>, NetError> {
43        self.service
44            .upgrade()
45            .map(|service| service.inner.windows_sampler())
46            .ok_or_else(|| NetError::from(ErrorKind::Closed))
47    }
48    #[cfg(any(windows, test))]
49    pub(super) fn windows_reachability_sampler(
50        &self,
51    ) -> Result<Arc<super::refresh::WindowsSampler>, NetError> {
52        self.service
53            .upgrade()
54            .map(|service| service.inner.windows_reachability_sampler())
55            .ok_or_else(|| NetError::from(ErrorKind::Closed))
56    }
57    /// Read the cached observation without starting or retrying monitoring.
58    pub fn snapshot(&self) -> Result<NetworkSnapshot, NetError> {
59        if let Some(error) = ::tokio::sync::watch::Receiver::borrow(&self.failure).clone() {
60            return Err(error);
61        }
62        match self.service.upgrade() {
63            Some(service) => service.inner.snapshot(),
64            None => Ok(::tokio::sync::watch::Receiver::borrow(&self.facts).clone()),
65        }
66    }
67    pub(crate) fn common_engine(&self) -> Result<Arc<CommonEngine>, NetError> {
68        self.service
69            .upgrade()
70            .map(|service| service.engine.clone())
71            .ok_or_else(|| NetError::from(ErrorKind::Closed))
72    }
73    pub(crate) fn is_closed(&self) -> bool {
74        self.service.upgrade().map_or(true, |service| {
75            match service.admission.lock() {
76                Ok(state) => state.closed,
77                Err(_) => {
78                    crate::log_e!(crate::common::log::log_def::LogType::Engine; "network_service_state", "error", "admission_lock_poisoned");
79                    true
80                }
81            }
82        })
83    }
84    pub(crate) fn acquire(&self) -> Result<NetworkLease, NetError> {
85        let service = self
86            .service
87            .upgrade()
88            .ok_or_else(|| NetError::from(ErrorKind::Closed))?;
89        // A recoverable Failed snapshot remains valid for explicit retry. A
90        // permanent publication error cannot admit new, unusable demand.
91        service.inner.snapshot()?;
92        let id = {
93            let mut state = service.admission.lock().map_err(NetError::from_poison)?;
94            if state.closed {
95                return Err(NetError::from(ErrorKind::Closed));
96            }
97            let id = state
98                .next_id
99                .checked_add(1)
100                .ok_or_else(|| NetError::from(ErrorKind::Internal))?;
101            service
102                .commands
103                .send(Command::Acquire(id))
104                .map_err(|_| NetError::from(ErrorKind::RuntimeUnavailable))?;
105            state.next_id = id;
106            state.active.insert(id);
107            id
108        };
109        Ok(NetworkLease {
110            inner: Arc::new(LeaseState {
111                id,
112                service: Arc::downgrade(&service),
113                released: Mutex::new(None),
114                closed: service.closed.clone(),
115            }),
116        })
117    }
118    pub(crate) fn subscribe_facts(&self) -> watch::Receiver<NetworkSnapshot> {
119        self.facts.clone()
120    }
121    pub(crate) fn subscribe_failure(&self) -> watch::Receiver<Option<NetError>> {
122        self.failure.clone()
123    }
124    pub(crate) fn subscribe_gate(&self) -> watch::Receiver<NetworkStatusSnapshot> {
125        self.gate.clone()
126    }
127}
128
129#[derive(Clone)]
130pub(crate) struct CleanupTicket {
131    finished: watch::Receiver<Option<Result<(), NetError>>>,
132}
133impl CleanupTicket {
134    fn pending() -> (watch::Sender<Option<Result<(), NetError>>>, Self) {
135        let (sender, finished) = watch::channel(None);
136        (sender, Self { finished })
137    }
138    pub(crate) fn is_finished(&self) -> bool {
139        matches!(
140            *::tokio::sync::watch::Receiver::borrow(&self.finished),
141            Some(Ok(()))
142        )
143    }
144    pub(crate) async fn wait(&self) -> Result<(), NetError> {
145        let mut finished = self.finished.clone();
146        loop {
147            if let Some(result) = finished.borrow_and_update().clone() {
148                return result;
149            }
150            finished
151                .changed()
152                .await
153                .map_err(|_| NetError::from(ErrorKind::RuntimeUnavailable))?;
154        }
155    }
156}
157
158#[derive(Clone)]
159pub(crate) struct NetworkLease {
160    inner: Arc<LeaseState>,
161}
162struct LeaseState {
163    id: u64,
164    service: Weak<SharedNetworkService>,
165    released: Mutex<Option<CleanupTicket>>,
166    closed: CleanupTicket,
167}
168impl NetworkLease {
169    pub(crate) fn ensure_started(&self) -> Result<(), NetError> {
170        self.inner.ensure(None)
171    }
172    pub(crate) async fn wait_started(&self) -> Result<NetworkSnapshot, NetError> {
173        let (sender, received) = oneshot::channel();
174        self.inner.ensure(Some(sender))?;
175        received
176            .await
177            .map_err(|_| NetError::from(ErrorKind::RuntimeUnavailable))?
178    }
179    pub(crate) fn release(&self) -> CleanupTicket {
180        self.inner.release()
181    }
182}
183
184impl LeaseState {
185    fn ensure(
186        &self,
187        waiter: Option<oneshot::Sender<Result<NetworkSnapshot, NetError>>>,
188    ) -> Result<(), NetError> {
189        let released = self.released.lock().map_err(NetError::from_poison)?;
190        if released.is_some() {
191            return Err(NetError::from(ErrorKind::Closed));
192        }
193        let service = self
194            .service
195            .upgrade()
196            .ok_or_else(|| NetError::from(ErrorKind::Closed))?;
197        let state = service.admission.lock().map_err(NetError::from_poison)?;
198        if state.closed || !state.active.contains(&self.id) {
199            return Err(NetError::from(ErrorKind::Closed));
200        }
201        service
202            .commands
203            .send(Command::Ensure(self.id, waiter))
204            .map_err(|_| NetError::from(ErrorKind::RuntimeUnavailable))
205    }
206    fn release(&self) -> CleanupTicket {
207        let mut released = match self.released.lock() {
208            Ok(state) => state,
209            Err(poisoned) => {
210                crate::log_e!(crate::common::log::log_def::LogType::Engine; "network_lease_release", "error", "poisoned_lease_recovered");
211                poisoned.into_inner()
212            }
213        };
214        if let Some(ticket) = released.as_ref() {
215            return ticket.clone();
216        }
217        let ticket = match self.service.upgrade() {
218            Some(service) => {
219                let mut admission = match service.admission.lock() {
220                    Ok(state) => state,
221                    Err(poisoned) => {
222                        crate::log_e!(crate::common::log::log_def::LogType::Engine; "network_lease_release", "error", "admission_lock_poisoned_recovered");
223                        poisoned.into_inner()
224                    }
225                };
226                admission.active.remove(&self.id);
227                if admission.closed {
228                    service.closed.clone()
229                } else {
230                    let (sender, ticket) = CleanupTicket::pending();
231                    if let Err(error) = service.commands.send(Command::Release(self.id, sender)) {
232                        if let Command::Release(_, sender) = error.0 {
233                            Completion::new(sender, &service.engine)
234                                .finish(Err(NetError::from(ErrorKind::RuntimeUnavailable)));
235                        }
236                    }
237                    ticket
238                }
239            }
240            None => self.closed.clone(),
241        };
242        *released = Some(ticket.clone());
243        ticket
244    }
245}
246impl Drop for LeaseState {
247    fn drop(&mut self) {
248        self.release();
249    }
250}
251
252struct Admission {
253    closed: bool,
254    next_id: u64,
255    active: HashSet<u64>,
256}
257pub(crate) struct SharedNetworkService {
258    engine: Arc<CommonEngine>,
259    inner: Arc<InnerNetStatusClient>,
260    admission: Mutex<Admission>,
261    commands: mpsc::UnboundedSender<Command>,
262    closed: CleanupTicket,
263}
264enum Command {
265    Acquire(u64),
266    Ensure(
267        u64,
268        Option<oneshot::Sender<Result<NetworkSnapshot, NetError>>>,
269    ),
270    Release(u64, watch::Sender<Option<Result<(), NetError>>>),
271    Close,
272}
273impl SharedNetworkService {
274    pub(crate) fn new(engine: Arc<CommonEngine>) -> Result<Arc<Self>, NetError> {
275        let inner = Arc::new(InnerNetStatusClient::new(engine.clone())?);
276        let (commands, receiver) = mpsc::unbounded_channel();
277        let (closed_sender, closed) = CleanupTicket::pending();
278        engine.runtime_handle().spawn(coordinate(
279            inner.clone(),
280            engine.clone(),
281            receiver,
282            closed_sender,
283        ));
284        Ok(Arc::new(Self {
285            engine,
286            inner,
287            commands,
288            admission: Mutex::new(Admission {
289                closed: false,
290                next_id: 0,
291                active: HashSet::new(),
292            }),
293            closed,
294        }))
295    }
296    pub(crate) fn context(self: &Arc<Self>) -> NetworkStatusContext {
297        NetworkStatusContext {
298            service: Arc::downgrade(self),
299            facts: self.inner.subscribe_facts(),
300            failure: self.inner.subscribe_failure(),
301            gate: self.inner.subscribe(),
302        }
303    }
304    pub(crate) fn request_close(&self) {
305        let newly_closed = {
306            let mut state = match self.admission.lock() {
307                Ok(state) => state,
308                Err(poisoned) => {
309                    crate::log_e!(crate::common::log::log_def::LogType::Engine; "network_service_close", "error", "admission_lock_poisoned_recovered");
310                    poisoned.into_inner()
311                }
312            };
313            if state.closed {
314                false
315            } else {
316                state.closed = true;
317                state.active.clear();
318                true
319            }
320        };
321        if newly_closed {
322            // Terminal facts become visible before returning. No admission lock
323            // is held while the source wakes its internal SDK readers.
324            self.inner.request_destroy();
325            let _ = self.commands.send(Command::Close);
326        }
327    }
328    #[cfg(test)]
329    pub(crate) fn inner_for_test(&self) -> Arc<InnerNetStatusClient> {
330        self.inner.clone()
331    }
332    #[cfg(test)]
333    pub(crate) fn active_consumers_for_test(&self) -> Result<usize, NetError> {
334        Ok(self
335            .admission
336            .lock()
337            .map_err(NetError::from_poison)?
338            .active
339            .len())
340    }
341    pub(crate) async fn shutdown(&self) -> Result<(), NetError> {
342        self.request_close();
343        self.closed.wait().await
344    }
345}
346
347impl Drop for SharedNetworkService {
348    fn drop(&mut self) {
349        self.request_close();
350    }
351}
352
353type StartFuture = Pin<Box<dyn Future<Output = Result<NetworkSnapshot, NetError>> + Send>>;
354/// This guard also reports task cancellation; dropping a sender is never treated
355/// as proof that provider resources have completed retirement.
356struct Completion {
357    sender: Option<watch::Sender<Option<Result<(), NetError>>>>,
358    engine: Arc<CommonEngine>,
359}
360impl Completion {
361    fn new(
362        sender: watch::Sender<Option<Result<(), NetError>>>,
363        engine: &Arc<CommonEngine>,
364    ) -> Self {
365        Self {
366            sender: Some(sender),
367            engine: engine.clone(),
368        }
369    }
370    fn finish(mut self, result: Result<(), NetError>) {
371        if let Some(sender) = self.sender.take() {
372            let engine = self.engine.clone();
373            self.engine.runtime_handle().spawn_blocking(move || {
374                // A Handle alone cannot keep accepted cleanup work alive.
375                let _runtime_owner = engine;
376                sender.send_replace(Some(result));
377            });
378        }
379    }
380}
381impl Drop for Completion {
382    fn drop(&mut self) {
383        if let Some(sender) = self.sender.take() {
384            let engine = self.engine.clone();
385            self.engine.runtime_handle().spawn_blocking(move || {
386                let _runtime_owner = engine;
387                sender.send_replace(Some(Err(NetError::from(ErrorKind::RuntimeUnavailable))));
388            });
389        }
390    }
391}
392fn notify_waiters(
393    engine: &Arc<CommonEngine>,
394    waiters: Vec<oneshot::Sender<Result<NetworkSnapshot, NetError>>>,
395    result: Result<NetworkSnapshot, NetError>,
396) {
397    for waiter in waiters {
398        let retained_engine = engine.clone();
399        let result = result.clone();
400        engine.runtime_handle().spawn_blocking(move || {
401            let _runtime_owner = retained_engine;
402            // Independent consumers must not share one user-waker stack.
403            let _ = waiter.send(result);
404        });
405    }
406}
407
408fn retire(
409    inner: &InnerNetStatusClient,
410    engine: &Arc<CommonEngine>,
411    permanent: bool,
412    sender: watch::Sender<Option<Result<(), NetError>>>,
413) {
414    let (finished, error) = inner.request_stop(permanent);
415    let completion = Completion::new(sender, engine);
416    engine.runtime_handle().spawn(async move {
417        let result = InnerNetStatusClient::wait_until_finished(finished).await;
418        completion.finish(result.and_then(|()| error.map_or(Ok(()), Err)));
419    });
420}
421async fn coordinate(
422    inner: Arc<InnerNetStatusClient>,
423    engine: Arc<CommonEngine>,
424    mut commands: mpsc::UnboundedReceiver<Command>,
425    closed: watch::Sender<Option<Result<(), NetError>>>,
426) {
427    let closed = Completion::new(closed, &engine);
428    let mut active = HashSet::new();
429    let mut start: Option<StartFuture> = None;
430    let mut waiters = Vec::<oneshot::Sender<Result<NetworkSnapshot, NetError>>>::new();
431    let mut retry_waiters = Vec::new();
432    let mut retry_requested = false;
433    let mut start_revision = 0;
434    loop {
435        tokio::select! {
436            biased;
437            command = commands.recv() => {
438                match command {
439                    Some(Command::Acquire(id)) => { active.insert(id); }
440                    Some(Command::Ensure(id, waiter)) if active.contains(&id) => {
441                        let snapshot = inner.snapshot();
442                        let failed_during_start = start.is_some() && snapshot.as_ref().is_ok_and(|snapshot| {
443                            snapshot.revision > start_revision && matches!(snapshot.state, MonitorState::Failed(_))
444                        });
445                        if failed_during_start {
446                            retry_requested = true;
447                            if let Some(waiter) = waiter { retry_waiters.push(waiter); }
448                        } else {
449                            if let Some(waiter) = waiter { waiters.push(waiter); }
450                            if start.is_none() {
451                                start_revision = snapshot.as_ref().map_or(0, |snapshot| snapshot.revision);
452                                let inner = inner.clone();
453                                start = Some(Box::pin(async move { inner.start().await }));
454                            }
455                        }
456                    }
457                    Some(Command::Ensure(_, waiter)) => {
458                        if let Some(waiter) = waiter { notify_waiters(&engine, vec![waiter], Err(NetError::from(ErrorKind::Closed))); }
459                    }
460                    Some(Command::Release(id, sender)) => {
461                        active.remove(&id);
462                        if active.is_empty() {
463                            drop(start.take());
464                            retry_requested = false;
465                            waiters.append(&mut retry_waiters);
466                            retire(&inner, &engine, false, sender);
467                            let result = inner.snapshot();
468                            notify_waiters(&engine, std::mem::take(&mut waiters), result);
469                        } else {
470                            Completion::new(sender, &engine).finish(Ok(()));
471                        }
472                    }
473                    Some(Command::Close) | None => {
474                        drop(start.take());
475                        waiters.append(&mut retry_waiters);
476                        notify_waiters(&engine, std::mem::take(&mut waiters), Err(NetError::from(ErrorKind::Closed)));
477                        let (finished, error) = inner.request_stop(true);
478                        // No commands need service after the terminal admission
479                        // transition. Only this final shutdown waits for resources.
480                        let result = InnerNetStatusClient::wait_until_finished(finished).await;
481                        closed.finish(result.and_then(|()| error.map_or(Ok(()), Err)));
482                        return;
483                    }
484                }
485            }
486            result = async {
487                match start.as_mut() {
488                    Some(start) => start.await,
489                    None => std::future::pending().await,
490                }
491            } => {
492                start = None;
493                notify_waiters(&engine, std::mem::take(&mut waiters), result);
494                if retry_requested && !active.is_empty() {
495                    retry_requested = false;
496                    waiters = std::mem::take(&mut retry_waiters);
497                    start_revision = inner.snapshot().map_or(0, |snapshot| snapshot.revision);
498                    let inner = inner.clone();
499                    start = Some(Box::pin(async move { inner.start().await }));
500                }
501            }
502        }
503    }
504}
505
506#[cfg(test)]
507mod tests {
508    use super::*;
509    type TestResult = Result<(), Box<dyn std::error::Error + Send + Sync>>;
510    fn check(condition: bool, message: &str) -> TestResult {
511        if condition {
512            Ok(())
513        } else {
514            Err(std::io::Error::other(message).into())
515        }
516    }
517    fn service() -> Result<Arc<SharedNetworkService>, NetError> {
518        SharedNetworkService::new(Arc::new(CommonEngine::new(16, 16)?))
519    }
520    struct BlockingWake {
521        entered: Mutex<Option<oneshot::Sender<()>>>,
522        release: Mutex<std::sync::mpsc::Receiver<()>>,
523    }
524    impl std::task::Wake for BlockingWake {
525        fn wake(self: Arc<Self>) {
526            if let Ok(mut entered) = self.entered.lock() {
527                if let Some(entered) = entered.take() {
528                    let _ = entered.send(());
529                }
530            }
531            if let Ok(release) = self.release.lock() {
532                let _ = release.recv_timeout(std::time::Duration::from_secs(5));
533            }
534        }
535    }
536    #[tokio::test]
537    async fn accepted_waiters_are_not_blocked_by_another_callers_waker() -> TestResult {
538        let engine = Arc::new(CommonEngine::new(16, 16)?);
539        let (entered, entered_wait) = oneshot::channel();
540        let (release, released) = std::sync::mpsc::channel();
541        let waker = std::task::Waker::from(Arc::new(BlockingWake {
542            entered: Mutex::new(Some(entered)),
543            release: Mutex::new(released),
544        }));
545        let (first_sender, mut first) = oneshot::channel();
546        let (second_sender, second) = oneshot::channel();
547        let first_pending = Pin::new(&mut first)
548            .poll(&mut std::task::Context::from_waker(&waker))
549            .is_pending();
550        check(first_pending, "first waiter was already complete")?;
551        notify_waiters(
552            &engine,
553            vec![first_sender, second_sender],
554            Err(NetError::from(ErrorKind::Closed)),
555        );
556        tokio::time::timeout(std::time::Duration::from_secs(5), entered_wait).await??;
557        let second_result = tokio::time::timeout(std::time::Duration::from_secs(2), second).await;
558        let _ = release.send(());
559        check(
560            second_result??.is_err(),
561            "second caller did not receive terminal result",
562        )?;
563        check(
564            first.await?.is_err(),
565            "first caller did not receive terminal result",
566        )?;
567        Ok(())
568    }
569
570    #[tokio::test]
571    async fn accepted_cleanup_notification_keeps_runtime_until_delivery() -> TestResult {
572        let engine = Arc::new(CommonEngine::new(16, 16)?);
573        let (sender, ticket) = CleanupTicket::pending();
574        let completion = Completion::new(sender, &engine);
575        let runtime_owner = Arc::downgrade(&engine);
576        drop(engine);
577        check(
578            runtime_owner.upgrade().is_some(),
579            "accepted cleanup lost its runtime owner",
580        )?;
581        completion.finish(Ok(()));
582        tokio::time::timeout(std::time::Duration::from_secs(5), ticket.wait()).await??;
583        Ok(())
584    }
585
586    #[tokio::test]
587    async fn snapshots_are_inert_and_leases_are_logical_and_idempotent() -> TestResult {
588        let service = service()?;
589        let context = service.context();
590        check(
591            matches!(context.snapshot()?.state, MonitorState::Stopped),
592            "new source is not stopped",
593        )?;
594        let lease = context.acquire()?;
595        let clone = lease.clone();
596        check(
597            service
598                .admission
599                .lock()
600                .map_err(NetError::from_poison)?
601                .active
602                .len()
603                == 1,
604            "clone added demand",
605        )?;
606        lease.release().wait().await?;
607        clone.release().wait().await?;
608        check(
609            service
610                .admission
611                .lock()
612                .map_err(NetError::from_poison)?
613                .active
614                .is_empty(),
615            "released demand leaked",
616        )?;
617        check(
618            matches!(context.snapshot()?.state, MonitorState::Stopped),
619            "acquisition started monitoring",
620        )?;
621        service.shutdown().await?;
622        Ok(())
623    }
624    #[tokio::test]
625    async fn closed_context_rejects_new_leases_and_preserves_terminal_cache() -> TestResult {
626        let service = service()?;
627        let context = service.context();
628        service.request_close();
629        check(context.acquire().is_err(), "closed context admitted demand")?;
630        check(
631            matches!(context.snapshot()?.state, MonitorState::Closed),
632            "close was not synchronous",
633        )?;
634        service.shutdown().await?;
635        drop(service);
636        check(
637            matches!(context.snapshot()?.state, MonitorState::Closed),
638            "terminal cache was lost",
639        )?;
640        Ok(())
641    }
642    fn gated_service() -> Result<
643        (
644            Arc<SharedNetworkService>,
645            mpsc::UnboundedReceiver<oneshot::Sender<()>>,
646            Arc<std::sync::atomic::AtomicUsize>,
647        ),
648        NetError,
649    > {
650        let service = service()?;
651        let (attempts, receiver) = mpsc::unbounded_channel();
652        let calls = Arc::new(std::sync::atomic::AtomicUsize::new(0));
653        let factory_calls = calls.clone();
654        service
655            .inner
656            .set_monitor_factory_for_test(Arc::new(move || {
657                factory_calls.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
658                let (release, ready) = oneshot::channel();
659                let _ = attempts.send(release);
660                Box::pin(async move {
661                    let _ = ready.await;
662                    Err(NetError::from(ErrorKind::Io))
663                })
664            }))?;
665        Ok((service, receiver, calls))
666    }
667    async fn attempt(
668        receiver: &mut mpsc::UnboundedReceiver<oneshot::Sender<()>>,
669    ) -> Result<oneshot::Sender<()>, Box<dyn std::error::Error + Send + Sync>> {
670        Ok(
671            tokio::time::timeout(std::time::Duration::from_secs(5), receiver.recv())
672                .await?
673                .ok_or("factory missing")?,
674        )
675    }
676    #[tokio::test]
677    async fn concurrent_demand_shares_pending_initialization_and_nonlast_release_is_isolated(
678    ) -> TestResult {
679        let (service, mut attempts, calls) = gated_service()?;
680        let a = service.context().acquire()?;
681        let b = service.context().acquire()?;
682        a.ensure_started()?;
683        b.ensure_started()?;
684        let release = attempt(&mut attempts).await?;
685        a.release().wait().await?;
686        check(
687            calls.load(std::sync::atomic::Ordering::SeqCst) == 1,
688            "concurrent demand duplicated provider",
689        )?;
690        check(
691            !release.is_closed(),
692            "nonlast release cancelled shared startup",
693        )?;
694        let mut waiting = Box::pin(b.wait_started());
695        check(
696            futures::poll!(&mut waiting).is_pending(),
697            "start waiter unexpectedly completed",
698        )?;
699        let _ = release.send(());
700        let result = tokio::time::timeout(std::time::Duration::from_secs(5), waiting).await?;
701        check(
702            matches!(result, Err(error) if error.kind() == ErrorKind::Io),
703            "shared startup error lost",
704        )?;
705        service.shutdown().await?;
706        Ok(())
707    }
708    #[tokio::test]
709    async fn failed_generation_can_retry_with_existing_lease_and_live_fact_stream() -> TestResult {
710        let (service, mut attempts, calls) = gated_service()?;
711        let context = service.context();
712        let lease = context.acquire()?;
713        let mut facts = context.subscribe_facts();
714        let first = lease.clone();
715        let waiting = tokio::spawn(async move { first.wait_started().await });
716        let _ = attempt(&mut attempts).await?.send(());
717        check(waiting.await?.is_err(), "failure was hidden")?;
718        check(
719            matches!(context.snapshot()?.state, MonitorState::Failed(_)),
720            "failure snapshot absent",
721        )?;
722        lease.ensure_started()?;
723        let second = attempt(&mut attempts).await?;
724        check(
725            calls.load(std::sync::atomic::Ordering::SeqCst) == 2,
726            "existing demand could not retry",
727        )?;
728        check(
729            facts.changed().await.is_ok(),
730            "recoverable failure closed stream",
731        )?;
732        lease.release().wait().await?;
733        check(second.is_closed(), "last release did not cancel retry")?;
734        service.shutdown().await?;
735        Ok(())
736    }
737    #[tokio::test]
738    async fn close_during_pending_start_finishes_waiters_and_prevents_revival() -> TestResult {
739        let (service, mut attempts, _) = gated_service()?;
740        let context = service.context();
741        let lease = context.acquire()?;
742        let waiter = lease.clone();
743        let waiting = tokio::spawn(async move { waiter.wait_started().await });
744        let _attempt = attempt(&mut attempts).await?;
745        service.request_close();
746        check(
747            matches!(context.snapshot()?.state, MonitorState::Closed),
748            "close did not publish terminal",
749        )?;
750        check(
751            matches!(waiting.await?, Err(error) if error.kind() == ErrorKind::Closed),
752            "pending start survived close",
753        )?;
754        lease.release().wait().await?;
755        check(context.acquire().is_err(), "closed service revived")?;
756        service.shutdown().await?;
757        Ok(())
758    }
759    #[tokio::test]
760    async fn service_drop_does_not_require_external_context_or_lease_drop() -> TestResult {
761        let (service, mut attempts, _) = gated_service()?;
762        let context = service.context();
763        let lease = context.acquire()?;
764        lease.ensure_started()?;
765        let _attempt = attempt(&mut attempts).await?;
766        drop(service);
767        check(
768            matches!(context.snapshot()?.state, MonitorState::Closed),
769            "external context kept engine alive",
770        )?;
771        lease.release().wait().await?;
772        check(
773            lease.ensure_started().is_err(),
774            "released context restarted engine",
775        )?;
776        Ok(())
777    }
778}
779
780#[cfg(test)]
781#[path = "shared_regression_tests.rs"]
782mod regression_tests;